[ { "path": ".gitbook/assets/.gitignore", "content": "# Default ignored files\n/shelf/\n/workspace.xml\n# Editor-based HTTP Client requests\n/httpRequests/\n# Datasource local storage ignored files\n/dataSources/\n/dataSources.local.xml\n" }, { "path": ".gitbook/assets/LICENSE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n" }, { "path": ".gitbook/assets/choose", "content": "\n\n\n\n\n\n\n\n \n \n \n \n \n \n \n \n\n\n\n \n \n \n \n \n \n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n Sign in to GitHub · GitHub\n\n\n\n \n\n \n\n\n\n \n \n\n \n\n \n \n \n \n \n\n\n\n \n\n \n\n\n\n\n \n\n \n\n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n\n\n \n\n\n\n \n\n \n\n\n \n \n \n \n\n \n\n \n\n\n\n \n \n\n\n \n\n \n\n \n\n \n \n \n\n\n\n\n\n \n\n \n\n \n \n\n
\n Skip to content\n \n \n \n \n\n\n
\n
\n \n \n \n\n \n
\n
\n\n\n
\n\n
\n\n\n\n\n\n\n\n\n \n \n\n\n \n\n\n\n\n \n
\n \n\n\n
\n\n\n \n
\n

Sign in to GitHub

\n
\n\n\n
\n\n\n\n\n \n
\n\n\n \n\n
\n\n
\n \n\n
\n \n \n \n\n\n\n\n\n\n\n\n \n\n Forgot password?\n
\n
\n
\n\n\n

\n New to GitHub?\n Create an account\n .\n

\n\n
\n\n
\n \n\n
\n \n
\n\n\n\n \n\n
\n \n \n\n \n \n
\n \n\n
\n
\n
\n
\n\n \n\n\n\n\n \n\n\n" }, { "path": ".gitbook/assets/compare", "content": "\n\n\n\n\n\n\n\n\n \n \n \n \n \n \n \n \n\n\n\n \n \n \n \n \n \n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n Compare · ksckaan1/uber-go-style-guide-tr · GitHub\n\n\n\n \n\n \n\n \n\n\n \n \n\n \n\n \n \n \n \n \n\n\n\n \n\n \n\n\n\n\n \n\n \n\n \n\n \n \n \n \n \n \n \n \n \n \n \n\n\n \n\n\n\n \n\n \n\n\n \n \n \n \n\n \n\n \n \n\n \n\n\n\n \n\n\n \n\n \n\n \n\n \n \n \n\n\n\n\n\n \n\n \n\n \n \n\n
\n Skip to content\n \n \n \n \n\n\n \n\n \n\n
\n \n\n
\n
\n \n \n \n\n \n\n
\n \n Sign up\n \n
\n\n
\n
\n
\n\n\n
\n
\n \n\n
\n
\n \n\n\n\n
\n
\n
\n \n
\n
\n\n
\n\n
\n \n Sign in\n \n
\n\n \n Sign up\n \n
\n
\n
\n
\n
\n\n
\n\n
\n\n\n\n\n\n\n\n
\n\n\n\n\n \n
\n\n\n \n \n\n\n \n\n\n\n\n \n
\n
\n \n \n \n\n\n\n\n\n
\n\n
\n\n
\n \n
\n \n \n\n \n \n ksckaan1\n \n /\n \n uber-go-style-guide-tr\n \n\n Public\n
\n\n\n
\n\n \n\n
\n\n
\n
\n\n\n \n\n
\n\n\n\n\n \n
\n \n \n\n\n \n \n
\n
\n

Compare changes

\n
Compare changes across branches, commits, tags, and more below.\n If you need to, you can also .\n
\n \n
\n
\n \n \n\n
\n
\n base repository:\n ksckaan1/uber-go-style-guide-tr\n\n \n \n \n \n \n\n \n \n
\n\n\n \n
\n base:\n master\n \n
\n
\n
\n Choose a base ref\n \n
\n\n \n \n
\n \n
\n\n
\n \n \n
\n\n
\n \n\n \n\n \n\n\n
\n
\n \n \n \n\n
\n
\n\n \n\n\n \n\n
\n\n \n \n \n
\n
\n\n
\n\n
\n\n \n \n\n\n
\n
\n head repository:\n ksckaan1/uber-go-style-guide-tr\n\n \n \n \n \n \n\n \n \n
\n\n\n \n
\n compare:\n master\n \n
\n
\n
\n Choose a head ref\n \n
\n\n \n \n
\n \n
\n\n
\n \n \n
\n\n
\n \n\n \n\n \n\n\n
\n
\n \n \n \n\n
\n
\n\n \n\n\n \n\n
\n\n \n \n \n
\n
\n\n
\n\n
\n\n
\n\n\n
\n
\n Choose different branches or forks above to discuss and review changes.\n \n Learn about pull requests\n \n
\n
\n\n
\n \n \n\n

Compare and review just about anything

\n

Branches, tags, commit ranges, and time ranges. In the same repository and across forks.

\n \n
\n
\n Example comparisons\n
\n\n\n
\n\n
\n\n\n
\n\n \n\n\n
\n
\n\n \n\n \n\n\n\n\n \n\n
\n \n \n\n \n \n
\n \n\n
\n
\n
\n
\n\n \n\n\n\n\n \n\n\n" }, { "path": ".gitbook/assets/labels", "content": "\n\n\n\n\n\n\n\n\n \n \n \n \n \n \n \n \n\n\n\n \n \n \n \n \n \n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n Labels · ksckaan1/uber-go-style-guide-tr · GitHub\n\n\n\n \n\n \n\n \n\n\n \n \n\n \n\n \n \n \n \n \n\n\n\n \n\n \n\n\n\n\n \n\n \n\n \n\n \n \n \n \n \n \n \n \n \n \n \n\n\n \n\n\n\n \n\n \n\n\n \n \n \n \n\n \n\n \n \n\n \n\n\n\n \n\n\n \n\n \n\n \n\n \n \n \n\n\n\n\n\n \n\n \n\n \n \n\n
\n Skip to content\n \n \n \n \n\n\n \n\n \n\n
\n \n\n
\n
\n \n \n \n\n \n\n
\n \n Sign up\n \n
\n\n
\n
\n
\n\n\n
\n
\n \n\n
\n
\n \n\n\n\n
\n
\n
\n \n
\n
\n\n
\n\n
\n \n Sign in\n \n
\n\n \n Sign up\n \n
\n
\n
\n
\n
\n\n
\n\n
\n\n\n\n\n\n\n\n
\n\n\n\n\n \n
\n\n\n \n \n\n\n \n\n\n\n\n \n
\n
\n \n \n\n \n\n\n\n\n\n
\n\n
\n\n
\n \n
\n \n \n\n \n \n ksckaan1\n \n /\n \n uber-go-style-guide-tr\n \n\n Public\n
\n\n\n
\n\n \n\n
\n\n
\n
\n\n\n \n\n
\n\n\n\n\n \n
\n \n \n\n\n \n \n
\n \n
\n
\n
\n \n\n\n
\n\n
\n
\n \n \n \n \n \n\n
\n\n
\n\n\n\n\n \n
\n \n \n\n\n

No labels!\n

\n

There aren’t any labels for this repository quite yet.\n

\n\n
\n
\n\n

\n 9\n labels\n

\n\n \n
\n \n Sort\n \n \n
\n Sort\n
\n
\n \n \n \n\n
Alphabetically
\n \n \n \n \n\n
Reverse alphabetically
\n \n \n \n \n\n
Most issues
\n \n \n \n \n\n
Fewest issues
\n \n
\n \n
\n\n\n
\n\n
\n
\n \n
\n\n
\n \n\n bug\n\n\n
\n \n\n bug\n\n\n
\n
\n\n
\n Something isn't working\n
\n\n
\n
\n\n\n\n
\n\n \n
\n\n
\n \n\n documentation\n\n\n
\n \n\n documentation\n\n\n
\n
\n\n
\n Improvements or additions to documentation\n
\n\n
\n
\n\n\n\n
\n\n \n
\n\n
\n \n\n duplicate\n\n\n
\n \n\n duplicate\n\n\n
\n
\n\n
\n This issue or pull request already exists\n
\n\n
\n
\n\n\n\n
\n\n \n
\n\n
\n \n\n enhancement\n\n\n
\n \n\n enhancement\n\n\n
\n
\n\n
\n New feature or request\n
\n\n
\n
\n\n\n\n
\n\n \n
\n\n
\n \n\n good first issue\n\n\n
\n \n\n good first issue\n\n\n
\n
\n\n
\n Good for newcomers\n
\n\n
\n
\n\n\n\n
\n\n \n
\n\n
\n \n\n help wanted\n\n\n
\n \n\n help wanted\n\n\n
\n
\n\n
\n Extra attention is needed\n
\n\n
\n
\n\n\n\n
\n\n \n
\n\n
\n \n\n invalid\n\n\n
\n \n\n invalid\n\n\n
\n
\n\n
\n This doesn't seem right\n
\n\n
\n
\n\n\n\n
\n\n \n
\n\n
\n \n\n question\n\n\n
\n \n\n question\n\n\n
\n
\n\n
\n Further information is requested\n
\n\n
\n
\n\n\n\n
\n\n \n
\n\n
\n \n\n wontfix\n\n\n
\n \n\n wontfix\n\n\n
\n
\n\n
\n This will not be worked on\n
\n\n
\n
\n\n\n\n
\n\n
\n
\n
\n\n
\n\n
\n\n\n
\n\n \n\n\n
\n
\n\n \n\n \n\n\n\n\n \n\n
\n \n \n\n \n \n
\n \n\n
\n
\n
\n
\n\n \n\n\n\n\n \n\n\n" }, { "path": ".gitbook/assets/milestones", "content": "\n\n\n\n\n\n\n\n\n \n \n \n \n \n \n \n \n\n\n\n \n \n \n \n \n \n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n Milestones - ksckaan1/uber-go-style-guide-tr · GitHub\n\n\n\n \n\n \n\n \n\n\n \n \n\n \n\n \n \n \n \n \n\n\n\n \n\n \n\n\n\n\n \n\n \n\n \n\n \n \n \n \n \n \n \n \n \n \n \n\n\n \n\n\n\n \n\n \n\n\n \n \n \n \n\n \n\n \n \n\n \n\n\n\n \n\n\n \n\n \n\n \n\n \n \n \n\n\n\n\n\n \n\n \n\n \n \n\n
\n Skip to content\n \n \n \n \n\n\n \n\n \n\n
\n \n\n
\n
\n \n \n \n\n \n\n
\n \n Sign up\n \n
\n\n
\n
\n
\n\n\n
\n
\n \n\n
\n
\n \n\n\n\n
\n
\n
\n \n
\n
\n\n
\n\n
\n \n Sign in\n \n
\n\n \n Sign up\n \n
\n
\n
\n
\n
\n\n
\n\n
\n\n\n\n\n\n\n\n
\n\n\n\n\n \n
\n\n\n \n \n\n\n \n\n\n\n\n \n
\n
\n \n \n\n \n\n\n\n\n\n
\n\n
\n\n
\n \n
\n \n \n\n \n \n ksckaan1\n \n /\n \n uber-go-style-guide-tr\n \n\n Public\n
\n\n\n
\n\n \n\n
\n\n
\n
\n\n\n \n\n
\n\n\n\n\n \n
\n \n \n\n\n \n \n
\n \n
\n \n\n\n
\n\n\n
\n
\n
\n \n \n \n\n 0\n Open\n\n \n \n \n\n 0\n Closed\n
\n\n
\n
\n Sort\n \n
\n Sort\n
\n
\n \n \n \n\n
Recently updated
\n \n \n \n \n\n
Furthest due date
\n \n \n \n \n\n
Closest due date
\n \n \n \n \n\n
Least complete
\n \n \n \n \n\n
Most complete
\n \n \n \n \n\n
Alphabetically
\n \n \n \n \n\n
Reverse alphabetically
\n \n \n \n \n\n
Most issues
\n \n \n \n \n\n
Least issues
\n \n
\n \n
\n
\n
\n
\n\n \n
\n \n \n\n\n

No Milestones found!\n

\n

If this project had milestones, we’d show you them here. Promise!\n

\n\n
\n
\n\n\n
\n\n \n\n\n
\n
\n\n \n\n \n\n\n\n\n \n\n
\n \n \n\n \n \n
\n \n\n
\n
\n
\n
\n\n \n\n\n\n\n \n\n\n" }, { "path": ".gitbook/assets/policy", "content": "\n\n\n\n \n \n \n \n \n \n \n \n\n\n\n \n \n \n \n \n \n\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n Security Policy · ksckaan1/uber-go-style-guide-tr · GitHub\n\n\n\n \n\n \n\n \n\n\n \n \n\n \n\n \n \n \n \n \n\n\n\n \n\n \n\n\n\n\n \n\n \n\n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n\n\n \n\n\n\n \n\n \n\n\n \n \n \n \n\n \n\n\n\n \n\n\n \n\n \n\n \n\n \n \n \n\n\n\n\n\n \n\n \n\n \n \n\n
\n Skip to content\n \n \n \n \n\n\n \n\n \n\n
\n \n\n
\n
\n \n \n \n\n \n\n
\n \n Sign up\n \n
\n\n
\n
\n
\n\n\n
\n
\n \n\n
\n
\n \n\n\n\n
\n
\n
\n \n
\n
\n\n
\n\n
\n \n Sign in\n \n
\n\n \n Sign up\n \n
\n
\n
\n
\n
\n\n
\n\n
\n\n\n\n\n\n\n\n
\n\n\n\n\n \n
\n\n\n \n \n\n\n \n\n\n\n\n \n
\n \n\n \n\n\n\n\n\n
\n\n
\n\n
\n \n
\n \n \n\n \n \n ksckaan1\n \n /\n \n uber-go-style-guide-tr\n \n\n Public\n
\n\n\n
\n\n \n\n
\n\n
\n
\n\n\n \n\n
\n\n\n\n\n \n
\n \n \n\n\n \n \n

Security: ksckaan1/uber-go-style-guide-tr

\n
\n
\n \n
\n\n \n\n
\n
\n \n
\n

No security policy detected

\n \n

This project has not set up a SECURITY.md file yet.

\n\n
\n
\n
\n\n\n
\n\n \n\n
\n \n\n \n\n\n\n\n \n\n
\n \n \n\n \n \n
\n \n\n
\n
\n
\n
\n\n \n\n\n\n\n \n\n" }, { "path": ".gitbook/assets/uber go style guide tr", "content": "\n\n \n \n \n \n \n \n" }, { "path": ".github/FUNDING.yml", "content": "# These are supported funding model platforms\n\ngithub: [ksckaan1]\n" }, { "path": "Golang Örnekler/Kullanıcı Bilgi Sistemi/main.go", "content": "package main\r\n\r\nimport (\r\n\t\"fmt\"\r\n)\r\n\r\nfunc main() {\r\n\tvar isim, soyisim, tcno string\r\n\tvar yas int\r\n\tvar tekrar = int(1)\r\n\tfor tekrar == 1 {\r\n\t\tfmt.Print(\"İsminiz-Soyisminiz Nedir?: \")\r\n\t\tfmt.Scanf(\"%s %s\", &isim, &soyisim)\r\n\t\tif isim == \"\" || soyisim == \"\" {\r\n\t\t\tfmt.Println(\"\\nİsim veya Soyisim Boş Girilemez.\")\r\n\t\t} else {\r\n\t\t\tbreak\r\n\t\t}\r\n\t}\r\n\tfor tekrar == 1 {\r\n\t\tfmt.Printf(\"\\nMerhaba %s, Kaç Yaşındasın?: \", isim)\r\n\t\tfmt.Scanf(\"%d\", &yas)\r\n\t\tif yas == 0 || yas < 0 {\r\n\t\t\tfmt.Println(\"\\nGeçersiz Yaş Girdiniz.\")\r\n\t\t} else {\r\n\t\t\tbreak\r\n\t\t}\r\n\t}\r\n\tfor tekrar == 1 {\r\n\t\tfmt.Print(\"\\nTC NO'nuz Nedir?: \")\r\n\t\tfmt.Scanf(\"%s\", &tcno)\r\n\t\tif len(tcno) != 11 {\r\n\t\t\tfmt.Println(\"\\nTC NO'nuz 11 Haneli olmalıdır.\")\r\n\t\t} else {\r\n\t\t\tbreak\r\n\t\t}\r\n\t}\r\n\r\n\tfmt.Printf(\"\\nİŞTE TÜM BİLGİLERİNİZ\\nİsim-Soyisim: %s %s\\nYaş: %d\\nTC NO: %s\", isim, soyisim, yas, tcno)\r\n\tfmt.Scanf(\"%s\")\r\n}\r\n" }, { "path": "Golang Örnekler/Pisagor Hesaplama/main.go", "content": "package main\r\n\r\nimport (\r\n\t\"fmt\"\r\n\t\"math\"\r\n)\r\n\r\nfunc main() {\r\n\tvar ken1, ken2, hipo float64\r\n\r\n\tfmt.Println(\"Dik üçgende Hipotenüs bulma programına hoşgeldiniz!\")\r\n\tfmt.Print(\"1. kenarı girin: \")\r\n\tfmt.Scan(&ken1)\r\n\tfmt.Print(\"\\n2. kenarı girin: \")\r\n\tfmt.Scan(&ken2)\r\n\thipo = math.Sqrt(math.Pow(ken1, 2) + math.Pow(ken2, 2))\r\n\tfmt.Printf(\"\\nHipotenüs: %f\\n Çıkmak için [ENTER] tuşuna basın...\", hipo)\r\n\tfmt.Scanf(\"%s\")\r\n}\r\n" }, { "path": "Golang Örnekler/Sayı Tahmin/sayitahmin.go", "content": "package main\r\n\r\nimport (\r\n\t\"fmt\" //Genel\r\n\t\"math/rand\" //rastgele sayı için\r\n\t\"os\" //Sistem\r\n\t\"os/exec\" //terminalde kod yürütme için\r\n\t\"runtime\" //Çalışma ortamı kodları için\r\n\t\"strconv\" //String'e çevirmek için\r\n\t\"time\" //Zaman fonksiyonları için\r\n)\r\n\r\nfunc main() {\r\n\r\n\ts1 := rand.NewSource(time.Now().UnixNano())\r\n\tr1 := rand.New(s1)\r\n\tsayi := strconv.Itoa(r1.Intn(10)) //rastgele sayı oluşturduk\r\n\tdöngü := true\r\n\ttemizle()\r\n\tfmt.Println(\"Sayı tahmin oyunu\")\r\n\tfmt.Print(\"Sayı yazın: \")\r\n\tvar tahmin string\r\n\tfor döngü == true { //döngü true iken çalışacak\r\n\r\n\t\tfmt.Scanf(\"%s\", &tahmin)\r\n\t\tif tahmin == sayi {\r\n\t\t\tdöngü = false\r\n\t\t\ttemizle()\r\n\t\t\tfmt.Printf(\"Tebrikler Doğru sayı: %s\", sayi)\r\n\t\t} else if tahmin > sayi {\r\n\t\t\ttemizle()\r\n\t\t\tfmt.Print(\"Bilemediniz,Tahmini küçültün\\nSayı Yazın: \")\r\n\t\t} else {\r\n\t\t\ttemizle()\r\n\t\t\tfmt.Print(\"Bilemediniz,Tahmini büyütün\\nSayı Yazın: \")\r\n\t\t}\r\n\t}\r\n}\r\nfunc temizle() { //Terminal Temizleme\r\n\tif runtime.GOOS == \"linux\" {\r\n\t\tcmd := exec.Command(\"clear\")\r\n\t\tcmd.Stdout = os.Stdout\r\n\t\tcmd.Run()\r\n\t} else {\r\n\t\tcmd := exec.Command(\"cls\")\r\n\t\tcmd.Stdout = os.Stdout\r\n\t\tcmd.Run()\r\n\t}\r\n}\r\n" }, { "path": "Golang Örnekler/Sunucu Oluşturucu/sunucuolusturucu.go", "content": "package main\r\n\r\nimport (\r\n\t\"fmt\"\r\n\t\"net/http\"\r\n)\r\n\r\nfunc main() {\r\n\tport := \"8000\"\r\n\tklasor := \"\"\r\n\tfmt.Println(\" ____ _ _ _ _ _ _ ____ _ _ ___ _ _ _ ____ _____ _ _ ____\\n/ ___|| | | | \\\\ | | | | |/ ___| | | | / _ \\\\| | | | | / ___|_ _| | | | _ \\\\\\n\\\\___ \\\\| | | | \\\\| | | | | | | | | | | | | | | | | | \\\\___ \\\\ | | | | | | |_) |\\n ___) | |_| | |\\\\ | |_| | |___| |_| | | |_| | |__| |_| |___) || | | |_| | _ < \\n|____/ \\\\___/|_| \\\\_|\\\\___/ \\\\____|\\\\___/ \\\\___/|_____\\\\___/|____/ |_| \\\\___/|_| \\\\_\\\\\")\r\n\tfmt.Println(\"####################################################################\")\r\n\tson := \"####################################################################\"\r\n\tfmt.Printf(\"Oluşturulacak portu giriniz (8000 için boş bırakın): \")\r\n\tfmt.Scanf(\"%s\", &port)\r\n\tif port == \"\" {\r\n\t\tport = \"8000\"\r\n\t} else if len(port) < 4 {\r\n\t\tport = \"8000\"\r\n\t\tfmt.Println(\"Portu 4 karakterden az girdiğiniz için 8000 olarak ayarlandı\")\r\n\t} else if len(port) > 4 {\r\n\t\tport = \"8000\"\r\n\t\tfmt.Println(\"Portu 4 karakterden fazla girdiğiniz için 800 olarak ayarlandı\")\r\n\t}\r\n\tfmt.Printf(\"Klasörün ismini giriniz (/ olmadan): \")\r\n\tfmt.Scanf(\"%s\", &klasor)\r\n\thttp.Handle(\"/\", http.FileServer(http.Dir(klasor)))\r\n\tfmt.Printf(\"http://localhost:%s oluşturuldu\\n%s\", port, son)\r\n\thttp.ListenAndServe(\":\"+port, nil)\r\n}\r\n" }, { "path": "LICENSE", "content": " GNU GENERAL PUBLIC LICENSE\r\n Version 3, 29 June 2007\r\n\r\n Copyright (C) 2007 Free Software Foundation, Inc. \r\n Everyone is permitted to copy and distribute verbatim copies\r\n of this license document, but changing it is not allowed.\r\n\r\n Preamble\r\n\r\n The GNU General Public License is a free, copyleft license for\r\nsoftware and other kinds of works.\r\n\r\n The licenses for most software and other practical works are designed\r\nto take away your freedom to share and change the works. By contrast,\r\nthe GNU General Public License is intended to guarantee your freedom to\r\nshare and change all versions of a program--to make sure it remains free\r\nsoftware for all its users. We, the Free Software Foundation, use the\r\nGNU General Public License for most of our software; it applies also to\r\nany other work released this way by its authors. You can apply it to\r\nyour programs, too.\r\n\r\n When we speak of free software, we are referring to freedom, not\r\nprice. Our General Public Licenses are designed to make sure that you\r\nhave the freedom to distribute copies of free software (and charge for\r\nthem if you wish), that you receive source code or can get it if you\r\nwant it, that you can change the software or use pieces of it in new\r\nfree programs, and that you know you can do these things.\r\n\r\n To protect your rights, we need to prevent others from denying you\r\nthese rights or asking you to surrender the rights. Therefore, you have\r\ncertain responsibilities if you distribute copies of the software, or if\r\nyou modify it: responsibilities to respect the freedom of others.\r\n\r\n For example, if you distribute copies of such a program, whether\r\ngratis or for a fee, you must pass on to the recipients the same\r\nfreedoms that you received. You must make sure that they, too, receive\r\nor can get the source code. And you must show them these terms so they\r\nknow their rights.\r\n\r\n Developers that use the GNU GPL protect your rights with two steps:\r\n(1) assert copyright on the software, and (2) offer you this License\r\ngiving you legal permission to copy, distribute and/or modify it.\r\n\r\n For the developers' and authors' protection, the GPL clearly explains\r\nthat there is no warranty for this free software. For both users' and\r\nauthors' sake, the GPL requires that modified versions be marked as\r\nchanged, so that their problems will not be attributed erroneously to\r\nauthors of previous versions.\r\n\r\n Some devices are designed to deny users access to install or run\r\nmodified versions of the software inside them, although the manufacturer\r\ncan do so. This is fundamentally incompatible with the aim of\r\nprotecting users' freedom to change the software. The systematic\r\npattern of such abuse occurs in the area of products for individuals to\r\nuse, which is precisely where it is most unacceptable. Therefore, we\r\nhave designed this version of the GPL to prohibit the practice for those\r\nproducts. If such problems arise substantially in other domains, we\r\nstand ready to extend this provision to those domains in future versions\r\nof the GPL, as needed to protect the freedom of users.\r\n\r\n Finally, every program is threatened constantly by software patents.\r\nStates should not allow patents to restrict development and use of\r\nsoftware on general-purpose computers, but in those that do, we wish to\r\navoid the special danger that patents applied to a free program could\r\nmake it effectively proprietary. To prevent this, the GPL assures that\r\npatents cannot be used to render the program non-free.\r\n\r\n The precise terms and conditions for copying, distribution and\r\nmodification follow.\r\n\r\n TERMS AND CONDITIONS\r\n\r\n 0. Definitions.\r\n\r\n \"This License\" refers to version 3 of the GNU General Public License.\r\n\r\n \"Copyright\" also means copyright-like laws that apply to other kinds of\r\nworks, such as semiconductor masks.\r\n\r\n \"The Program\" refers to any copyrightable work licensed under this\r\nLicense. Each licensee is addressed as \"you\". \"Licensees\" and\r\n\"recipients\" may be individuals or organizations.\r\n\r\n To \"modify\" a work means to copy from or adapt all or part of the work\r\nin a fashion requiring copyright permission, other than the making of an\r\nexact copy. The resulting work is called a \"modified version\" of the\r\nearlier work or a work \"based on\" the earlier work.\r\n\r\n A \"covered work\" means either the unmodified Program or a work based\r\non the Program.\r\n\r\n To \"propagate\" a work means to do anything with it that, without\r\npermission, would make you directly or secondarily liable for\r\ninfringement under applicable copyright law, except executing it on a\r\ncomputer or modifying a private copy. Propagation includes copying,\r\ndistribution (with or without modification), making available to the\r\npublic, and in some countries other activities as well.\r\n\r\n To \"convey\" a work means any kind of propagation that enables other\r\nparties to make or receive copies. Mere interaction with a user through\r\na computer network, with no transfer of a copy, is not conveying.\r\n\r\n An interactive user interface displays \"Appropriate Legal Notices\"\r\nto the extent that it includes a convenient and prominently visible\r\nfeature that (1) displays an appropriate copyright notice, and (2)\r\ntells the user that there is no warranty for the work (except to the\r\nextent that warranties are provided), that licensees may convey the\r\nwork under this License, and how to view a copy of this License. If\r\nthe interface presents a list of user commands or options, such as a\r\nmenu, a prominent item in the list meets this criterion.\r\n\r\n 1. Source Code.\r\n\r\n The \"source code\" for a work means the preferred form of the work\r\nfor making modifications to it. \"Object code\" means any non-source\r\nform of a work.\r\n\r\n A \"Standard Interface\" means an interface that either is an official\r\nstandard defined by a recognized standards body, or, in the case of\r\ninterfaces specified for a particular programming language, one that\r\nis widely used among developers working in that language.\r\n\r\n The \"System Libraries\" of an executable work include anything, other\r\nthan the work as a whole, that (a) is included in the normal form of\r\npackaging a Major Component, but which is not part of that Major\r\nComponent, and (b) serves only to enable use of the work with that\r\nMajor Component, or to implement a Standard Interface for which an\r\nimplementation is available to the public in source code form. A\r\n\"Major Component\", in this context, means a major essential component\r\n(kernel, window system, and so on) of the specific operating system\r\n(if any) on which the executable work runs, or a compiler used to\r\nproduce the work, or an object code interpreter used to run it.\r\n\r\n The \"Corresponding Source\" for a work in object code form means all\r\nthe source code needed to generate, install, and (for an executable\r\nwork) run the object code and to modify the work, including scripts to\r\ncontrol those activities. However, it does not include the work's\r\nSystem Libraries, or general-purpose tools or generally available free\r\nprograms which are used unmodified in performing those activities but\r\nwhich are not part of the work. For example, Corresponding Source\r\nincludes interface definition files associated with source files for\r\nthe work, and the source code for shared libraries and dynamically\r\nlinked subprograms that the work is specifically designed to require,\r\nsuch as by intimate data communication or control flow between those\r\nsubprograms and other parts of the work.\r\n\r\n The Corresponding Source need not include anything that users\r\ncan regenerate automatically from other parts of the Corresponding\r\nSource.\r\n\r\n The Corresponding Source for a work in source code form is that\r\nsame work.\r\n\r\n 2. Basic Permissions.\r\n\r\n All rights granted under this License are granted for the term of\r\ncopyright on the Program, and are irrevocable provided the stated\r\nconditions are met. This License explicitly affirms your unlimited\r\npermission to run the unmodified Program. The output from running a\r\ncovered work is covered by this License only if the output, given its\r\ncontent, constitutes a covered work. This License acknowledges your\r\nrights of fair use or other equivalent, as provided by copyright law.\r\n\r\n You may make, run and propagate covered works that you do not\r\nconvey, without conditions so long as your license otherwise remains\r\nin force. You may convey covered works to others for the sole purpose\r\nof having them make modifications exclusively for you, or provide you\r\nwith facilities for running those works, provided that you comply with\r\nthe terms of this License in conveying all material for which you do\r\nnot control copyright. Those thus making or running the covered works\r\nfor you must do so exclusively on your behalf, under your direction\r\nand control, on terms that prohibit them from making any copies of\r\nyour copyrighted material outside their relationship with you.\r\n\r\n Conveying under any other circumstances is permitted solely under\r\nthe conditions stated below. Sublicensing is not allowed; section 10\r\nmakes it unnecessary.\r\n\r\n 3. Protecting Users' Legal Rights From Anti-Circumvention Law.\r\n\r\n No covered work shall be deemed part of an effective technological\r\nmeasure under any applicable law fulfilling obligations under article\r\n11 of the WIPO copyright treaty adopted on 20 December 1996, or\r\nsimilar laws prohibiting or restricting circumvention of such\r\nmeasures.\r\n\r\n When you convey a covered work, you waive any legal power to forbid\r\ncircumvention of technological measures to the extent such circumvention\r\nis effected by exercising rights under this License with respect to\r\nthe covered work, and you disclaim any intention to limit operation or\r\nmodification of the work as a means of enforcing, against the work's\r\nusers, your or third parties' legal rights to forbid circumvention of\r\ntechnological measures.\r\n\r\n 4. Conveying Verbatim Copies.\r\n\r\n You may convey verbatim copies of the Program's source code as you\r\nreceive it, in any medium, provided that you conspicuously and\r\nappropriately publish on each copy an appropriate copyright notice;\r\nkeep intact all notices stating that this License and any\r\nnon-permissive terms added in accord with section 7 apply to the code;\r\nkeep intact all notices of the absence of any warranty; and give all\r\nrecipients a copy of this License along with the Program.\r\n\r\n You may charge any price or no price for each copy that you convey,\r\nand you may offer support or warranty protection for a fee.\r\n\r\n 5. Conveying Modified Source Versions.\r\n\r\n You may convey a work based on the Program, or the modifications to\r\nproduce it from the Program, in the form of source code under the\r\nterms of section 4, provided that you also meet all of these conditions:\r\n\r\n a) The work must carry prominent notices stating that you modified\r\n it, and giving a relevant date.\r\n\r\n b) The work must carry prominent notices stating that it is\r\n released under this License and any conditions added under section\r\n 7. This requirement modifies the requirement in section 4 to\r\n \"keep intact all notices\".\r\n\r\n c) You must license the entire work, as a whole, under this\r\n License to anyone who comes into possession of a copy. This\r\n License will therefore apply, along with any applicable section 7\r\n additional terms, to the whole of the work, and all its parts,\r\n regardless of how they are packaged. This License gives no\r\n permission to license the work in any other way, but it does not\r\n invalidate such permission if you have separately received it.\r\n\r\n d) If the work has interactive user interfaces, each must display\r\n Appropriate Legal Notices; however, if the Program has interactive\r\n interfaces that do not display Appropriate Legal Notices, your\r\n work need not make them do so.\r\n\r\n A compilation of a covered work with other separate and independent\r\nworks, which are not by their nature extensions of the covered work,\r\nand which are not combined with it such as to form a larger program,\r\nin or on a volume of a storage or distribution medium, is called an\r\n\"aggregate\" if the compilation and its resulting copyright are not\r\nused to limit the access or legal rights of the compilation's users\r\nbeyond what the individual works permit. Inclusion of a covered work\r\nin an aggregate does not cause this License to apply to the other\r\nparts of the aggregate.\r\n\r\n 6. Conveying Non-Source Forms.\r\n\r\n You may convey a covered work in object code form under the terms\r\nof sections 4 and 5, provided that you also convey the\r\nmachine-readable Corresponding Source under the terms of this License,\r\nin one of these ways:\r\n\r\n a) Convey the object code in, or embodied in, a physical product\r\n (including a physical distribution medium), accompanied by the\r\n Corresponding Source fixed on a durable physical medium\r\n customarily used for software interchange.\r\n\r\n b) Convey the object code in, or embodied in, a physical product\r\n (including a physical distribution medium), accompanied by a\r\n written offer, valid for at least three years and valid for as\r\n long as you offer spare parts or customer support for that product\r\n model, to give anyone who possesses the object code either (1) a\r\n copy of the Corresponding Source for all the software in the\r\n product that is covered by this License, on a durable physical\r\n medium customarily used for software interchange, for a price no\r\n more than your reasonable cost of physically performing this\r\n conveying of source, or (2) access to copy the\r\n Corresponding Source from a network server at no charge.\r\n\r\n c) Convey individual copies of the object code with a copy of the\r\n written offer to provide the Corresponding Source. This\r\n alternative is allowed only occasionally and noncommercially, and\r\n only if you received the object code with such an offer, in accord\r\n with subsection 6b.\r\n\r\n d) Convey the object code by offering access from a designated\r\n place (gratis or for a charge), and offer equivalent access to the\r\n Corresponding Source in the same way through the same place at no\r\n further charge. You need not require recipients to copy the\r\n Corresponding Source along with the object code. If the place to\r\n copy the object code is a network server, the Corresponding Source\r\n may be on a different server (operated by you or a third party)\r\n that supports equivalent copying facilities, provided you maintain\r\n clear directions next to the object code saying where to find the\r\n Corresponding Source. Regardless of what server hosts the\r\n Corresponding Source, you remain obligated to ensure that it is\r\n available for as long as needed to satisfy these requirements.\r\n\r\n e) Convey the object code using peer-to-peer transmission, provided\r\n you inform other peers where the object code and Corresponding\r\n Source of the work are being offered to the general public at no\r\n charge under subsection 6d.\r\n\r\n A separable portion of the object code, whose source code is excluded\r\nfrom the Corresponding Source as a System Library, need not be\r\nincluded in conveying the object code work.\r\n\r\n A \"User Product\" is either (1) a \"consumer product\", which means any\r\ntangible personal property which is normally used for personal, family,\r\nor household purposes, or (2) anything designed or sold for incorporation\r\ninto a dwelling. In determining whether a product is a consumer product,\r\ndoubtful cases shall be resolved in favor of coverage. For a particular\r\nproduct received by a particular user, \"normally used\" refers to a\r\ntypical or common use of that class of product, regardless of the status\r\nof the particular user or of the way in which the particular user\r\nactually uses, or expects or is expected to use, the product. A product\r\nis a consumer product regardless of whether the product has substantial\r\ncommercial, industrial or non-consumer uses, unless such uses represent\r\nthe only significant mode of use of the product.\r\n\r\n \"Installation Information\" for a User Product means any methods,\r\nprocedures, authorization keys, or other information required to install\r\nand execute modified versions of a covered work in that User Product from\r\na modified version of its Corresponding Source. The information must\r\nsuffice to ensure that the continued functioning of the modified object\r\ncode is in no case prevented or interfered with solely because\r\nmodification has been made.\r\n\r\n If you convey an object code work under this section in, or with, or\r\nspecifically for use in, a User Product, and the conveying occurs as\r\npart of a transaction in which the right of possession and use of the\r\nUser Product is transferred to the recipient in perpetuity or for a\r\nfixed term (regardless of how the transaction is characterized), the\r\nCorresponding Source conveyed under this section must be accompanied\r\nby the Installation Information. But this requirement does not apply\r\nif neither you nor any third party retains the ability to install\r\nmodified object code on the User Product (for example, the work has\r\nbeen installed in ROM).\r\n\r\n The requirement to provide Installation Information does not include a\r\nrequirement to continue to provide support service, warranty, or updates\r\nfor a work that has been modified or installed by the recipient, or for\r\nthe User Product in which it has been modified or installed. Access to a\r\nnetwork may be denied when the modification itself materially and\r\nadversely affects the operation of the network or violates the rules and\r\nprotocols for communication across the network.\r\n\r\n Corresponding Source conveyed, and Installation Information provided,\r\nin accord with this section must be in a format that is publicly\r\ndocumented (and with an implementation available to the public in\r\nsource code form), and must require no special password or key for\r\nunpacking, reading or copying.\r\n\r\n 7. Additional Terms.\r\n\r\n \"Additional permissions\" are terms that supplement the terms of this\r\nLicense by making exceptions from one or more of its conditions.\r\nAdditional permissions that are applicable to the entire Program shall\r\nbe treated as though they were included in this License, to the extent\r\nthat they are valid under applicable law. If additional permissions\r\napply only to part of the Program, that part may be used separately\r\nunder those permissions, but the entire Program remains governed by\r\nthis License without regard to the additional permissions.\r\n\r\n When you convey a copy of a covered work, you may at your option\r\nremove any additional permissions from that copy, or from any part of\r\nit. (Additional permissions may be written to require their own\r\nremoval in certain cases when you modify the work.) You may place\r\nadditional permissions on material, added by you to a covered work,\r\nfor which you have or can give appropriate copyright permission.\r\n\r\n Notwithstanding any other provision of this License, for material you\r\nadd to a covered work, you may (if authorized by the copyright holders of\r\nthat material) supplement the terms of this License with terms:\r\n\r\n a) Disclaiming warranty or limiting liability differently from the\r\n terms of sections 15 and 16 of this License; or\r\n\r\n b) Requiring preservation of specified reasonable legal notices or\r\n author attributions in that material or in the Appropriate Legal\r\n Notices displayed by works containing it; or\r\n\r\n c) Prohibiting misrepresentation of the origin of that material, or\r\n requiring that modified versions of such material be marked in\r\n reasonable ways as different from the original version; or\r\n\r\n d) Limiting the use for publicity purposes of names of licensors or\r\n authors of the material; or\r\n\r\n e) Declining to grant rights under trademark law for use of some\r\n trade names, trademarks, or service marks; or\r\n\r\n f) Requiring indemnification of licensors and authors of that\r\n material by anyone who conveys the material (or modified versions of\r\n it) with contractual assumptions of liability to the recipient, for\r\n any liability that these contractual assumptions directly impose on\r\n those licensors and authors.\r\n\r\n All other non-permissive additional terms are considered \"further\r\nrestrictions\" within the meaning of section 10. If the Program as you\r\nreceived it, or any part of it, contains a notice stating that it is\r\ngoverned by this License along with a term that is a further\r\nrestriction, you may remove that term. If a license document contains\r\na further restriction but permits relicensing or conveying under this\r\nLicense, you may add to a covered work material governed by the terms\r\nof that license document, provided that the further restriction does\r\nnot survive such relicensing or conveying.\r\n\r\n If you add terms to a covered work in accord with this section, you\r\nmust place, in the relevant source files, a statement of the\r\nadditional terms that apply to those files, or a notice indicating\r\nwhere to find the applicable terms.\r\n\r\n Additional terms, permissive or non-permissive, may be stated in the\r\nform of a separately written license, or stated as exceptions;\r\nthe above requirements apply either way.\r\n\r\n 8. Termination.\r\n\r\n You may not propagate or modify a covered work except as expressly\r\nprovided under this License. Any attempt otherwise to propagate or\r\nmodify it is void, and will automatically terminate your rights under\r\nthis License (including any patent licenses granted under the third\r\nparagraph of section 11).\r\n\r\n However, if you cease all violation of this License, then your\r\nlicense from a particular copyright holder is reinstated (a)\r\nprovisionally, unless and until the copyright holder explicitly and\r\nfinally terminates your license, and (b) permanently, if the copyright\r\nholder fails to notify you of the violation by some reasonable means\r\nprior to 60 days after the cessation.\r\n\r\n Moreover, your license from a particular copyright holder is\r\nreinstated permanently if the copyright holder notifies you of the\r\nviolation by some reasonable means, this is the first time you have\r\nreceived notice of violation of this License (for any work) from that\r\ncopyright holder, and you cure the violation prior to 30 days after\r\nyour receipt of the notice.\r\n\r\n Termination of your rights under this section does not terminate the\r\nlicenses of parties who have received copies or rights from you under\r\nthis License. If your rights have been terminated and not permanently\r\nreinstated, you do not qualify to receive new licenses for the same\r\nmaterial under section 10.\r\n\r\n 9. Acceptance Not Required for Having Copies.\r\n\r\n You are not required to accept this License in order to receive or\r\nrun a copy of the Program. Ancillary propagation of a covered work\r\noccurring solely as a consequence of using peer-to-peer transmission\r\nto receive a copy likewise does not require acceptance. However,\r\nnothing other than this License grants you permission to propagate or\r\nmodify any covered work. These actions infringe copyright if you do\r\nnot accept this License. Therefore, by modifying or propagating a\r\ncovered work, you indicate your acceptance of this License to do so.\r\n\r\n 10. Automatic Licensing of Downstream Recipients.\r\n\r\n Each time you convey a covered work, the recipient automatically\r\nreceives a license from the original licensors, to run, modify and\r\npropagate that work, subject to this License. You are not responsible\r\nfor enforcing compliance by third parties with this License.\r\n\r\n An \"entity transaction\" is a transaction transferring control of an\r\norganization, or substantially all assets of one, or subdividing an\r\norganization, or merging organizations. If propagation of a covered\r\nwork results from an entity transaction, each party to that\r\ntransaction who receives a copy of the work also receives whatever\r\nlicenses to the work the party's predecessor in interest had or could\r\ngive under the previous paragraph, plus a right to possession of the\r\nCorresponding Source of the work from the predecessor in interest, if\r\nthe predecessor has it or can get it with reasonable efforts.\r\n\r\n You may not impose any further restrictions on the exercise of the\r\nrights granted or affirmed under this License. For example, you may\r\nnot impose a license fee, royalty, or other charge for exercise of\r\nrights granted under this License, and you may not initiate litigation\r\n(including a cross-claim or counterclaim in a lawsuit) alleging that\r\nany patent claim is infringed by making, using, selling, offering for\r\nsale, or importing the Program or any portion of it.\r\n\r\n 11. Patents.\r\n\r\n A \"contributor\" is a copyright holder who authorizes use under this\r\nLicense of the Program or a work on which the Program is based. The\r\nwork thus licensed is called the contributor's \"contributor version\".\r\n\r\n A contributor's \"essential patent claims\" are all patent claims\r\nowned or controlled by the contributor, whether already acquired or\r\nhereafter acquired, that would be infringed by some manner, permitted\r\nby this License, of making, using, or selling its contributor version,\r\nbut do not include claims that would be infringed only as a\r\nconsequence of further modification of the contributor version. For\r\npurposes of this definition, \"control\" includes the right to grant\r\npatent sublicenses in a manner consistent with the requirements of\r\nthis License.\r\n\r\n Each contributor grants you a non-exclusive, worldwide, royalty-free\r\npatent license under the contributor's essential patent claims, to\r\nmake, use, sell, offer for sale, import and otherwise run, modify and\r\npropagate the contents of its contributor version.\r\n\r\n In the following three paragraphs, a \"patent license\" is any express\r\nagreement or commitment, however denominated, not to enforce a patent\r\n(such as an express permission to practice a patent or covenant not to\r\nsue for patent infringement). To \"grant\" such a patent license to a\r\nparty means to make such an agreement or commitment not to enforce a\r\npatent against the party.\r\n\r\n If you convey a covered work, knowingly relying on a patent license,\r\nand the Corresponding Source of the work is not available for anyone\r\nto copy, free of charge and under the terms of this License, through a\r\npublicly available network server or other readily accessible means,\r\nthen you must either (1) cause the Corresponding Source to be so\r\navailable, or (2) arrange to deprive yourself of the benefit of the\r\npatent license for this particular work, or (3) arrange, in a manner\r\nconsistent with the requirements of this License, to extend the patent\r\nlicense to downstream recipients. \"Knowingly relying\" means you have\r\nactual knowledge that, but for the patent license, your conveying the\r\ncovered work in a country, or your recipient's use of the covered work\r\nin a country, would infringe one or more identifiable patents in that\r\ncountry that you have reason to believe are valid.\r\n\r\n If, pursuant to or in connection with a single transaction or\r\narrangement, you convey, or propagate by procuring conveyance of, a\r\ncovered work, and grant a patent license to some of the parties\r\nreceiving the covered work authorizing them to use, propagate, modify\r\nor convey a specific copy of the covered work, then the patent license\r\nyou grant is automatically extended to all recipients of the covered\r\nwork and works based on it.\r\n\r\n A patent license is \"discriminatory\" if it does not include within\r\nthe scope of its coverage, prohibits the exercise of, or is\r\nconditioned on the non-exercise of one or more of the rights that are\r\nspecifically granted under this License. You may not convey a covered\r\nwork if you are a party to an arrangement with a third party that is\r\nin the business of distributing software, under which you make payment\r\nto the third party based on the extent of your activity of conveying\r\nthe work, and under which the third party grants, to any of the\r\nparties who would receive the covered work from you, a discriminatory\r\npatent license (a) in connection with copies of the covered work\r\nconveyed by you (or copies made from those copies), or (b) primarily\r\nfor and in connection with specific products or compilations that\r\ncontain the covered work, unless you entered into that arrangement,\r\nor that patent license was granted, prior to 28 March 2007.\r\n\r\n Nothing in this License shall be construed as excluding or limiting\r\nany implied license or other defenses to infringement that may\r\notherwise be available to you under applicable patent law.\r\n\r\n 12. No Surrender of Others' Freedom.\r\n\r\n If conditions are imposed on you (whether by court order, agreement or\r\notherwise) that contradict the conditions of this License, they do not\r\nexcuse you from the conditions of this License. If you cannot convey a\r\ncovered work so as to satisfy simultaneously your obligations under this\r\nLicense and any other pertinent obligations, then as a consequence you may\r\nnot convey it at all. For example, if you agree to terms that obligate you\r\nto collect a royalty for further conveying from those to whom you convey\r\nthe Program, the only way you could satisfy both those terms and this\r\nLicense would be to refrain entirely from conveying the Program.\r\n\r\n 13. Use with the GNU Affero General Public License.\r\n\r\n Notwithstanding any other provision of this License, you have\r\npermission to link or combine any covered work with a work licensed\r\nunder version 3 of the GNU Affero General Public License into a single\r\ncombined work, and to convey the resulting work. The terms of this\r\nLicense will continue to apply to the part which is the covered work,\r\nbut the special requirements of the GNU Affero General Public License,\r\nsection 13, concerning interaction through a network will apply to the\r\ncombination as such.\r\n\r\n 14. Revised Versions of this License.\r\n\r\n The Free Software Foundation may publish revised and/or new versions of\r\nthe GNU General Public License from time to time. Such new versions will\r\nbe similar in spirit to the present version, but may differ in detail to\r\naddress new problems or concerns.\r\n\r\n Each version is given a distinguishing version number. If the\r\nProgram specifies that a certain numbered version of the GNU General\r\nPublic License \"or any later version\" applies to it, you have the\r\noption of following the terms and conditions either of that numbered\r\nversion or of any later version published by the Free Software\r\nFoundation. If the Program does not specify a version number of the\r\nGNU General Public License, you may choose any version ever published\r\nby the Free Software Foundation.\r\n\r\n If the Program specifies that a proxy can decide which future\r\nversions of the GNU General Public License can be used, that proxy's\r\npublic statement of acceptance of a version permanently authorizes you\r\nto choose that version for the Program.\r\n\r\n Later license versions may give you additional or different\r\npermissions. However, no additional obligations are imposed on any\r\nauthor or copyright holder as a result of your choosing to follow a\r\nlater version.\r\n\r\n 15. Disclaimer of Warranty.\r\n\r\n THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY\r\nAPPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT\r\nHOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY\r\nOF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,\r\nTHE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM\r\nIS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF\r\nALL NECESSARY SERVICING, REPAIR OR CORRECTION.\r\n\r\n 16. Limitation of Liability.\r\n\r\n IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\r\nWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS\r\nTHE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY\r\nGENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE\r\nUSE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF\r\nDATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD\r\nPARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),\r\nEVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF\r\nSUCH DAMAGES.\r\n\r\n 17. Interpretation of Sections 15 and 16.\r\n\r\n If the disclaimer of warranty and limitation of liability provided\r\nabove cannot be given local legal effect according to their terms,\r\nreviewing courts shall apply local law that most closely approximates\r\nan absolute waiver of all civil liability in connection with the\r\nProgram, unless a warranty or assumption of liability accompanies a\r\ncopy of the Program in return for a fee.\r\n\r\n END OF TERMS AND CONDITIONS\r\n\r\n How to Apply These Terms to Your New Programs\r\n\r\n If you develop a new program, and you want it to be of the greatest\r\npossible use to the public, the best way to achieve this is to make it\r\nfree software which everyone can redistribute and change under these terms.\r\n\r\n To do so, attach the following notices to the program. It is safest\r\nto attach them to the start of each source file to most effectively\r\nstate the exclusion of warranty; and each file should have at least\r\nthe \"copyright\" line and a pointer to where the full notice is found.\r\n\r\n \r\n Copyright (C) \r\n\r\n This program is free software: you can redistribute it and/or modify\r\n it under the terms of the GNU General Public License as published by\r\n the Free Software Foundation, either version 3 of the License, or\r\n (at your option) any later version.\r\n\r\n This program is distributed in the hope that it will be useful,\r\n but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n GNU General Public License for more details.\r\n\r\n You should have received a copy of the GNU General Public License\r\n along with this program. If not, see .\r\n\r\nAlso add information on how to contact you by electronic and paper mail.\r\n\r\n If the program does terminal interaction, make it output a short\r\nnotice like this when it starts in an interactive mode:\r\n\r\n Copyright (C) \r\n This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\r\n This is free software, and you are welcome to redistribute it\r\n under certain conditions; type `show c' for details.\r\n\r\nThe hypothetical commands `show w' and `show c' should show the appropriate\r\nparts of the General Public License. Of course, your program's commands\r\nmight be different; for a GUI interface, you would use an \"about box\".\r\n\r\n You should also get your employer (if you work as a programmer) or school,\r\nif any, to sign a \"copyright disclaimer\" for the program, if necessary.\r\nFor more information on this, and how to apply and follow the GNU GPL, see\r\n.\r\n\r\n The GNU General Public License does not permit incorporating your program\r\ninto proprietary programs. If your program is a subroutine library, you\r\nmay consider it more useful to permit linking proprietary applications with\r\nthe library. If this is what you want to do, use the GNU Lesser General\r\nPublic License instead of this License. But first, please read\r\n.\r\n" }, { "path": "README.md", "content": "# GİRİŞ\n\n**Giriş**\n\n Bu eğitim kaynağında Golang programlama dili hakkında bilgilerdirici ön yazı, kullanım şekline ve örneklerine bakacağız. Bu kitapla pratik yapabilirsiniz. Kitap ileri seviye Go programlama içermeyecektir.\n\n**Bu Kitap Kimlere Hitap Ediyor?**\n\nBu kitap;\n\n* Go programlama dilini öğrenmek isteyen,\n* Go’da giriş seviyesinde bilgi sahibi olan,\n* Go’da orta seviyede bilgi sahibi olan,\n* veya daha önce başka dillere aşina olan,\n\n kişilere hitap ediyor\n\n**Amaç**\n\nKitabın Amacı;\n\n* Golang için Türkçe kaynak oluşturmak\n* Golang için ücretsiz eğitim kaynağı oluşturmak\n* Golang dilinin temel yapısını öğretmek\n\n**Kitabın İçeriği Hakkında**\n\nKitabın içeriğinde Go programlama dilinden “Go”, “Golang” ve “Go Programlama Dili” olarak bahsediyor olunacaktır. Hepsi aynı anlama geliyor. Genellikle kodların kullanım şekli ve yapısından bahsedilecektir. Tabi ki işleyişi anlayabilmemiz için örnekler ile pekiştirilecektir.\n\n Bu kitap sayesinde ülkemizde şuanda diğer dillere göre daha az bilinen ve hakkında fikir sahibi olan kişilerin sayısı az olan bu programlama dili hakkında kaynak oluşturulacaktır.\n" }, { "path": "SUMMARY.md", "content": "# Table of contents\n\n## KİTAP HAKKINDA\n\n* [GİRİŞ](README.md)\n* [Katkıda Bulunanlar](kitap-hakkinda/katkida-bulunanlar.md)\n\n## BÖLÜM 1 (Ön Eğitim) \n\n* [Golang Hakkında](boeluem-1/golang-hakkinda.md)\n* [Sıkça Sorulan Sorular](boeluem-1/sikca-sorulan-sorular.md)\n* [Go Derleyicisi Kurulumu](boeluem-1/go-derleyicisi-kurulumu.md)\n* [VSCode Go Eklentisi Yükleme](boeluem-1/bilgisayariniz-uezerinde-go-gelistirme.md)\n* [Go Projesi Oluşturma](boeluem-1/go-projesi-olusturma.md)\n* [Merhaba Dünya](boeluem-1/merhaba-duenya.md)\n* [VSCode Varsayılan Hata Ayıklayıcıyı Seçme](boeluem-1/vscode-varsayilan-hata-ayiklayiciyi-secme.md)\n* [Farklı Platformlara Build (İnşa) Etme](boeluem-1/farkli-platformlara-build-insa-etme.md)\n* [Klasör Build Etme](boeluem-1/klasoer-build-etme.md)\n* [Paketler](boeluem-1/paketler.md)\n* [Yorum Satırı](boeluem-1/yorum-satiri.md)\n* [Veri Tipleri](boeluem-1/veri-tipleri.md)\n* [Aritmetik Operatörler](boeluem-1/aritmetik-operatoerler.md)\n* [İlişkisel Operatörler](boeluem-1/iliskisel-operatoerler.md)\n* [Mantıksal Operatörler](boeluem-1/mantiksal-operatoerler.md)\n* [Atama Operatörleri](boeluem-1/atama-operatoerleri.md)\n* [Değişkenler ve Atanması](boeluem-1/degiskenler-ve-atanmasi.md)\n* [Sabitler](boeluem-1/sabitler.md)\n* [Kod Gruplama İşlemi](boeluem-1/kod-gruplama-islemi.md)\n* [Tür Dönüşümü](boeluem-1/tuer-doenuesuemue.md)\n* [Bölüm 1 Sınav](https://kaan-kuscu.involve.me/go-programlama-birinci-bolum-sinavi)\n\n## BÖLÜM 2 (İşlem Yapma) \n\n* [Fonksiyonlar](boeluem-2/fonksiyonlar.md)\n* [Fonksiyon Çeşitleri](boeluem-2/fonksiyon-cesitleri.md)\n* [Anonim Fonksiyonlar](boeluem-2/anonim-fonksiyonlar.md)\n* [Boş Tanımlayıcılar](boeluem-2/bos-tanimlayicilar.md)\n* [Döngüler](boeluem-2/doengueler.md)\n* [If-Else](boeluem-2/if-else.md)\n* [Switch](boeluem-2/switch.md)\n* [Defer](boeluem-2/defer.md)\n* [Pointers (İşaretçiler)](boeluem-2/pointers-isaretciler.md)\n* [Bölüm 2 Sınav](https://kaan-kuscu.involve.me/go-programlama-ikinci-bolum-sinavi)\n\n## BÖLÜM 3 (Gruplama) \n\n* [Struct](boeluem-3/struct.md)\n* [Anonim Struct'lar](boeluem-3/anonim-struct-metodlar.md)\n* [Struct Fonksiyonlar (Methodlar)](boeluem-3/struct-fonksiyonlar-methodlar.md)\n* [Diziler (Arrays)](boeluem-3/diziler-arrays.md)\n* [Dilimler (Slices)](boeluem-3/dilimler-slices.md)\n* [Range](boeluem-3/range.md)\n* [Map](boeluem-3/map.md)\n* [Interface](boeluem-3/arayuez-interface.md)\n* [Dinamik Değişkenler](pratik-bilgiler/dinamik-degiskenler.md)\n* [Generics](boeluem-3/generics.md)\n\n## BÖLÜM 4 (Eş zamanlılık) \n\n* [Goroutine](boeluem-4/untitled.md)\n* [Kanallar (Channels)](boeluem-4/kanallar-channels.md)\n* [Anonim Goroutine Fonksiyonlar](boeluem-4/anonim-goroutine-fonksiyonlar.md)\n* [WaitGroup ile Asenkron İşlemleri Beklemek](boeluem-4/waitgroup-ile-goroutinein-tamamlanmasini-beklemek.md)\n* [Mutex ile Asenkron İşlem Sırası](boeluem-4/mutex-ile-asenkron-islem-sirasi.md)\n* [Zamanlayıcılar (Tickers)](boeluem-4/zamanlayicilar-tickers.md)\n* [Select](boeluem-4/select.md)\n\n## BÖLÜM 5\n\n* [init() Fonksiyonu (Ön Yükleme)](boeluem-5/init-fonksiyonu-oen-yuekleme.md)\n* [Import (Kütüphane Ekleme) Yöntemleri](boeluem-5/import-kuetuephane-ekleme-yoentemleri.md)\n* [Dışa Aktarma (Exporting)](boeluem-5/disa-aktarma-exporting.md)\n* [Print Fonksiyonu Birkaç İnceleme](boeluem-5/print-fonksiyonu-birkac-inceleme.md)\n* [Format ve Kaçış Karakterleri](boeluem-5/format-ve-kacis-karakterleri.md)\n* [Çok Satırlı String Oluşturma](boeluem-5/cok-satirli-string-olusturma.md)\n* [Sprintf](boeluem-5/sprintf.md)\n* [Golang'te Kullanıcıdan Giriş Alma](boeluem-5/golangte-kullanicidan-giris-alma.md)\n* [Testing (Test Etme)](boeluem-5/testing-test-etme.md)\n* [Panic & Recover](boeluem-5/panic-and-recover.md)\n\n## BÖLÜM 6 (Paketler)\n\n* [Strings](boeluem-6-paketler/strings.md)\n* [os/exec (Komut Satırına Erişim)](boeluem-6-paketler/os-exec-komut-satirina-erisim.md)\n* [Komut Satırı Argümanları (Args)](boeluem-6-paketler/komut-satiri-arguemanlari-args.md)\n* [Komut Satırı Bayrakları (Flags)](boeluem-6-paketler/komut-satiri-bayraklari-flags.md)\n* [os/signal](boeluem-6-paketler/os-signal.md)\n* [Sort (Sıralama)](boeluem-6-paketler/sort-siralama.md)\n* [Strconv (String Çeviri)](boeluem-6-paketler/strconv-string-ceviri.md)\n* [Log (Kayıt)](boeluem-6-paketler/log-kayit.md)\n* [Paket (Kütüphane) Yazmak](boeluem-6-paketler/paket-kuetuephane-yazmak.md)\n* [Regexp (Kurallı İfadeler)](boeluem-6-paketler/regexp-kuralli-ifadeler.md)\n\n## BÖLÜM 7 (Dosya İşlemleri)\n\n* [Çapraz Platform Dosya Yolları](boeluem-7-dosya-islemleri/capraz-platform-dosya-yollari.md)\n* [İşletim Sistemini Görme](boeluem-7-dosya-islemleri/isletim-sistemini-goerme.md)\n* [Dosya Varlığı Kontrolü](boeluem-7-dosya-islemleri/dosya-varligi-kontrolue.md)\n* [ioutil ile Dosya Okuma ve Yazma](boeluem-7-dosya-islemleri/ioutil-ile-dosya-okuma-ve-yazma.md)\n* [Bir Dizindeki Dosya ve Klasörleri Sıralama](boeluem-7-dosya-islemleri/bir-dizindeki-dosya-ve-klasoerleri-siralama.md)\n* [XML Parsing (Ayrıştırma)](boeluem-7-dosya-islemleri/xml-parsing-ayristirma.md)\n* [JSON Parsing (Ayrıştırma)](boeluem-7-dosya-islemleri/json-parsing-ayristirma/README.md)\n * [Dinamik JSON Parsing Yöntemleri](boeluem-7-dosya-islemleri/json-parsing-ayristirma/dinamik-json-parsing-yoentemleri.md)\n* [ini Dosyası Okuma ve Düzenleme](boeluem-7-dosya-islemleri/ini-dosyasi-okuma-ve-duezenleme.md)\n* [Web Scrapper (goquery)](boeluem-7-dosya-islemleri/web-scrapper.md)\n* [chromedp (Web Driver)](boeluem-7-dosya-islemleri/chromedp-web-driver.md)\n\n## VERİTABANI\n\n* [sqlite3](veritabani/sqlite3.md)\n* [MySQL](veritabani/mysql.md)\n* [MongoDB](veritabani/mongodb.md)\n* [GORM](veritabani/gorm.md)\n\n## Web Sunucu (Server), Ağ İşlemleri \n\n* [net/http ile Web Server Oluşturma](web-sunucu-server-ag-istemleri/net-http-ile-web-server-olusturma.md)\n* [HTML Şablonlar (Templates)](web-sunucu-server-ag-istemleri/html-sablonlar-templates.md)\n* [Statik Kütüphanesi ile Dosyaları Uygulamaya Gömme](web-sunucu-server-ag-istemleri/statik-kuetuephanesi-ile-dosyalari-uygulamaya-goemme.md)\n* [Gin Web Kütüphanesi](web-sunucu-server-ag-istemleri/gin-web-kuetuephanesi/README.md)\n * [Gin Dosya Yükleme](web-sunucu-server-ag-istemleri/gin-web-kuetuephanesi/gin-dosya-yuekleme.md)\n* [gRPC](web-sunucu-server-ag-istemleri/grpc.md)\n* [Heroku'da Go Uygulaması Yayınlama](web-sunucu-server-ag-istemleri/herokuda-go-uygulamasi-yayinlama.md)\n* [HTTP İstekleri (Requests)](web-sunucu-server-ag-istemleri/requests.md)\n* [RabbitMQ](web-sunucu-server-ag-istemleri/rabbitmq/README.md)\n * [RabbitMQ Kurulumu](web-sunucu-server-ag-istemleri/rabbitmq/rabbitmq-kurulumu.md)\n * [Basitçe RabbitMQ Kullanımı](web-sunucu-server-ag-istemleri/rabbitmq/basitce-rabbitmq-kullanimi.md)\n\n## GUI (Grafiksel Kullanıcı Arayüzü) \n\n* [WebView](gui/webview.md)\n* [notify (Bildirim)](gui/notify-bildirim.md)\n\n## Mikro-denetleyiciler\n\n* [Gobot ile Arduino Yanıp-Sönen LED Yapımı](mikro-denetleyiciler/gobot-ile-arduino-yanip-soenen-led-yapimi.md)\n* [Tinygo ile Küçük Yerler için Golang](mikro-denetleyiciler/tinygo-ile-kuecuek-yerler-icin-golang.md)\n\n## CLI\n\n* [🐍 Cobra CLI](cli/cobra-cli.md)\n\n## ⚙ Yapılandırma\n\n* [🐍 Viper](yapilandirma/viper.md)\n\n## Pratik Bilgiler\n\n* [Go Geliştiricileri için Makefile](pratik-bilgiler/go-gelistiricileri-icin-makefile.md)\n* [Derleme (Build) Detayını Görme](pratik-bilgiler/derleme-build-detayini-goerme.md)\n* [Visual Studio Code için Golang Özelleştirmeleri](pratik-bilgiler/visual-studio-code-icin-golang-oezellestirmeleri.md)\n\n## 👾 PLUS\n\n* [Uber Go Stil Kılavuzu](https://github.com/ksckaan1/uber-go-style-guide-tr)\n" }, { "path": "boeluem-1/aritmetik-operatoerler.md", "content": "# Aritmetik Operatörler\n\nAritmetik operatörler programlamada matematiksel işlemler yapabilmemize olanak sağlar.\n\n| Operatör | Açıklama | Örnek |\n| -------- | --------------------------- | ----- |\n| + | Toplar | 2+5 |\n| - | Çıkarır | 10-3 |\n| \\* | Çarpar | 3\\*4 |\n| / | Böler | 10/2 |\n| % | Bölümden kalanı verir (Mod) | 10%3 |\n| ++ | 1 arttırır | 1++ |\n| -- | 1 eksiltir | 1-- |\n" }, { "path": "boeluem-1/atama-operatoerleri.md", "content": "# Atama Operatörleri\n\nAtama operatörleri değişkenlere ve sabitlere değer atamak için kullanılır. Aşağıdaki tabloda c’nin değeri 10’dur. (c=10)\n\n| Operatör | Açıklama | Örnek |\n| -------- | ------------------------------ | ----- |\n| = | Atama Operatörüdür | c=2 |\n| += | Kendiyle toplar | c+=2 |\n| -= | Kendinden çıkarır | c-=2 |\n| \\*= | Kendiyle çarpar | c\\*=2 |\n| /= | Kendine böler | c/=2 |\n| %= | Kendine bölümünden kalanı atar | c%=3 |\n" }, { "path": "boeluem-1/bilgisayariniz-uezerinde-go-gelistirme.md", "content": "# VSCode Go Eklentisi Yükleme\n\nGo'yu indirdiğimize göre bize Go kodlarımızı yazacağımız bir Tümleşik Geliştirme Ortamı (IDE) lazım. IDE’ler kodlarımızı yazarken kodların doğruluğunu kontrol eder ve kod yazarken önerilerde bulunur. Bu da kod yazarken işimizi kolaylaştırır.\n\nÇoğu programlama dili ile geliştirme yaparken kullanılan ve Go yazanların da popüler olarak kullandığı **Visual Studio Code** programınu kullanabilirsiniz.\n\nBuradan İndirebilirsiniz\n\n[https://code.visualstudio.com/Download](https://code.visualstudio.com/Download)\n\nGNU/Linux OS kullananlara yine kullandıkları dağıtımın uygulama deposundan indirmeleri tavsiye edilir.\n\nVisual Studio Code’dan ileriki zamanlarda **vscode** olarak bahsedilecek.\n\nGo eklentisinin düzgün bir şekilde kurulabilmesi için bilgisayarımızda **git** komut-satırı uygulaması bulunması gerekir. Çünkü eklentinin yüklenmesinden sonra Go eklentisi VSCode için 15 civarı aracı otomatik indirecek. Git’in yüklü olup olmadığını öğrenmek için komut satırına aşağıdakileri yazın:\n\nEğer versiyon numarasını gördüyseniz yüklü demektir. Eğer yüklü değilse veya git’i güncellemek istiyorsanız ki, mutlaka öneririm, aşağıda nasıl yükleneceğini görebilirsiniz.\n\n`git --version`\n\n### Windows MacOS\n\nWindows için: [Buradan İndirebilirsiniz](https://git-scm.com/download/win)\n\nMacOS: [Buradan İndirebilirsiniz.](https://git-scm.com/download/mac)\n\n### **GNU/Linux İşletim Sistemleri**\n\n#### **Debian/Ubuntu**\n\n`sudo apt-get install git`\n\n#### **Fedora**\n\n`dnf install git`\n\n#### **Arch Linux**\n\n`sudo pacman -S git`\n\n#### **Gentoo**\n\n`emerge --ask --verbose dev-vcs/git`\n\n#### **openSUSE**\n\n`zypper install git`\n\n#### **Mageia**\n\n`urpmi git`\n\nGit kurulumunu da yaptığımıza göre VSCode için Go eklentisini kurabiliriz.\n\n![VS Code Go Eklentisi](../.gitbook/assets/DeepinScreenshot\\_select-area\\_20191006213837.webp)\n\nVscode’un sol tarafından **Extension** (Eklentiler) sekmesine geçiyoruz. Arama kutusuna **go** yazıyoruz. Resimde de seçili olan Go eklentisini yeşil **Install (Yükle)** butonuna basarak yüklüyoruz. Yeniden başlatma isterse başlatmayı unutmayın.\n\nDaha sonra **main.go** adında bir dosya oluşturup VSCode ile açalım. main.go dosyasının içerisine rastgele birşeyler yazdığımızda VSCode sağ alt tarafta bize uyarı verecektir.\n\n![VS Code Go Uyarısı](../.gitbook/assets/golang-plugins-all.webp)\n\n**Install All** diyerek Go geliştirmemize yazrdımcı olacak araçların kurulumunu başlatalım.\n\nKurulum bize 15 civarı araç kuracak. Başarı ile kurulan araçların yanında **SUCCEED** ibaresi yer alır.\n\nTüm araçlarımız başarıyla kurulunca artık VSCode üzerinden Go geliştirmeye hazır olacaksınız.\n\n##\n" }, { "path": "boeluem-1/degiskenler-ve-atanmasi.md", "content": "# Değişkenler ve Atanması\n\n**Değişkenler** içerisinde değer barındırarak RAM’e kaydettiğimiz bilgilerdir. Değişkenler programımızın işleyişinde önemli bir role sahiptir. Değişkenleri şu şekillerde atayabiliriz. Değişkenler **var** ifadesi ile atanır. Tabi ki zorunlu değildir.\n\n```go\nvar isim string = “Ali”\nvar yas int = 20\nvar ogrenci bool = true\n```\n\nYukarıdaki yazdıklarımızı inceleyecek olursak;\n\n**var** ile değişken atadığımızı belirtiyoruz. **isim** diye bir değişken adı atadık ve içine **“Ali**” değerinde **string** tipinde bir değer yerleştirdik. String tipi değerler çift tırnak içine yazılır.\n\nAynı şekilde **yas** adında değişken oluşturduk. **yas** değişkeni içerisine **int** tipinde **20** değerini yerleştirdik Son olarak **ogrenci** adında bir değişken oluşturduk ve **true** değerinde **boolean** tipinde bir atama yaptık.\n\nGolang’ta değişken adı oluştururken Türkçe karakterler kullanabiliriz. Örnek olarak **ogrenci** yerine öğrenci yazabilirdik. Ama başka bir programlama diline geçtiğinizde Türkçe harf desteklememesi halinde alışkanlıklarınızı değiştirmeniz gerekecek. O yüzden Türkçe karakter kullanmamanızı tavsiye ederim. Tabi ki zorunlu değil.\n\nProgramlama dillerinde, matematiğin aksine **= (eşittir)** işareti eşitlik için değil, atamalar için kullanılır.\n\nDeğişkenlerin atanması için farklı yöntemler de var. Diğer yöntemlere değinmek gerekirse;\n\nDeğişken atamasında illaki değişkenin veri tipini belirtmemiz gerekmez. Yazdığımız değere göre Golang otomatik olarak veri tipini algılar.\n\n```go\nvar isim = “Ali”\nvar yas = 20\nvar ogrenci = true\n```\n\n**isim** değişkeninin değerini çift tırnak arasına yazdığımız için **string** veri tipinde olduğunu algılayacaktır.\n\n**yas** değişkeninin değerini sayı olarak girdiğimiz için **int** tipinde olduğunu algılar. Eğer 20 değil de 2.12312 gibi küsüratlı bir değer girseydik veri tipini **float** olarak algılardı.\n\n**ogrenci** değişkeninin değerini mantıksal olarak girdiğimiz için **boolean** veri tipinde olduğunu algılayacaktır.\n\nEn basit şekilde değişken ataması yapmak istersek;\n\n```go\nisim:=”Ali”\nyas:=20\nogrenci:=true\n```\n\nBaşına **var** eklemeden de değişken atamak mümkündür. Bu şekilde yapmak için **:=** işaretlerini kullanırız. Aynı şekilde bu yöntemde de verinin tipi otomatik algılanır.\n\nEğer değişken tanımlar iken değer kısmını boş bırakırsak yani; **var yas int** şeklinde yazarsak, önceki konuda da bahsettiğimiz gibi varsayılan olarak **0** değerini alır.\n" }, { "path": "boeluem-1/farkli-platformlara-build-insa-etme.md", "content": "# Farklı Platformlara Build (İnşa) Etme\n\nGolang projemizi build (inşa) ederken, yani çalıştırılabilir bir dosya üretirken **go build dosya.go** şeklinde build ederiz. Bu işlem varsayılan olarak kullanmakta olduğumuz işletim sistemi için build işlemi yapar. Yani Windows kullanıyorsak Windows’ta çalışmak üzere Linux İS kullanıyorsak Linux İS’te çalışmak üzere dosya oluşturur. Aynı şekilde sistemimizin mimarisi 32bit ise 32bit için, 64bit ise 64bit için çalıştırılabilir dosya üretir. Örnek olarak sistemimiz Windows 64bit ise oluşturduğumuz çalıştırılabilir dosya (exe dosyası) sadece Windows 64bitlerde çalışır.\n\nEğer farklı işletim sistemi için bir çalıştırılabilir dosya üretmek istiyorsak aşağıdaki komutu kullanmamız gerekir.\n\n`env GOOS=hedef-sistem GOARCH=hedef-mimari go build hedef-dosya`\n\nÖrnek olarak, **main.go** dosyamızı **Windows 32bit** sistemler için build etmek istersek aşağıdaki komutları girmemiz gerekir.\n\n`env GOOS=windows GOARCH=386 go build main.go`\n\nBu işlem ile main.exe adında bir dosya elde ederiz. Bu dosya Windows 32bit sistemlerde çalışabilir. Biliyorsunuz ki 32bit uygulamalar 64bit sistemlerde çalışır ;fakat 64bit uygulamalar 32bit sistemlerde çalışmaz. Onun için bir uygulama build ediyorken bunu aklınızdan çıkarmayın. Golang’ın dosya build edebildiği işletim sistemi ve mimari sayısı oldukça fazladır.\n\nGolang’ın build edebildiği tüm işletim sistemi ve mimarilerine bakmak gerekir ise;\n\n| GOOS | GOARCH |\n| --------- | -------- |\n| android | arm |\n| darwin | 386 |\n| darwin | amd64 |\n| darwin | arm |\n| darwin | arm64 |\n| dragonfly | amd64 |\n| freebsd | 386 |\n| freebsd | amd64 |\n| freebsd | arm |\n| linux | 386 |\n| linux | amd64 |\n| linux | arm |\n| linux | arm64 |\n| linux | ppc64 |\n| linux | ppc64le |\n| linux | mips |\n| linux | mipsle |\n| linux | mips64 |\n| linux | mips64le |\n| netbsd | 386 |\n| netbsd | arm64 |\n| netbsd | arm |\n| openbsd | 386 |\n| openbsd | arm64 |\n| openbsd | arm |\n| plan9 | 386 |\n| plan9 | amd64 |\n| solaris | amd64 |\n| windows | 386 |\n| windows | amd64 |\n\n\\* Tablo harf sıralamasına göre yapılmıştır.\n\nBirkaç örnek daha yapmak gerekirse;\n\n**Windows 64bit Build**\n\n`env GOOS=windows GOARCH=amd64 go build main.go`\n\n**Linux 32bit Build**\n\n`env GOOS=linux GOARCH=386 go build main.go`\n\n**MacOS 64bit Build**\n\n`env GOOS=darwin GOARCH=amd64 go build main.go`\n" }, { "path": "boeluem-1/go-derleyicisi-kurulumu.md", "content": "# Go Derleyicisi Kurulumu\n\nÖncelikle bilgisayarımız üzerinde nasıl Go ile yazılım geliştireceğimize bakalım. Öncelikle Golang’ın resmi sitesinden Go derleyiciyi indiriyoruz.\n\nBuradan İndirebilirsiniz\n\n[https://golang.org/dl/](https://golang.org/dl/)\n\nGo'nun basit bir kurulumu var o yüzden kurulumu atlıyoruz.\n\nGNU/Linux OS kullananlara tavsiye,\n\nKullandığınız dağıtımın uygulama deposundan Golang’ı indirin. Sizin için daha kolay olur. Eğer son Go versiyonunu yüklemek istiyorsanız ve uygulama deponuzda son versiyon yoksa [https://golang.org/dl/](https://golang.org/dl/) adresinden Linux versiyonunu indirebilirsiniz.\n\nUygulama depolarından indirmek için:\n\n| GNU/Linux Dağıtımı | Komut |\n| ------------------------------------------------------------------------------------------------------------------------ | ----------------------- |\n| ![](../.gitbook/assets/debian-icon.png)![](../.gitbook/assets/ubuntu-icon.png)![](../.gitbook/assets/linuxmint-icon.png) | sudo apt install golang |\n| ![](../.gitbook/assets/archlinux-icon.png)![](../.gitbook/assets/manjaro-icon.png) | sudo pacman -S go |\n" }, { "path": "boeluem-1/go-projesi-olusturma.md", "content": "# Go Projesi Oluşturma\n\nGo kurulumu ve paket yükleme işlemleri sonrasında oluşan klasör yapısını kullanarak projeleri burada barındırabiliriz. Normalde herhangi bir klasörde Go geliştirmeniz mümkündür fakat Go geliştiricilerin doğru bulduğu klasör mimarisinde geliştirmek size daha sağlıklı bir süreç sağlayabilir.\n\nVarsayılan kurulumda `c:/users/{user-name}/go` klasöründe **bin**, **pkg**, **src** adında üç klasör oluşturulur.\n\n**bin** klasörü paket yöneticisi ile install komutu kullanılarak deploy edilen executable dosyaları barındırır.\n\n**pkg** klasörü üçüncü sınıf paketler indirildiğinde derlenmiş şekilde bu klasör altında barındırır. Aynı zamanda kaynak kodları **src** klasörüne koyar. pkg klasörü derlenme süresini hızlandırmak için halihazırda derlenmiş bir kod içerir. Kendi projelerinizde import ettiğiniz paketlerin geldiği yer burasıdır.\n\n**src** klasörü geliştirme yapacağınız projelerinizin barındırılacağı klasördür. Burada projelerinizi belirli bir düzende barındırmanız sizin için sağlıklı olacaktır. Aşağıdaki gösterilen yapıda projelerinizi geliştirebilirsiniz. Bu yapı sayesinde **Git** üzerinde bulunan projelerinizdeki karışıklığı önleyebilirsiniz.\n\n### Varsayılan GOPATH Klasörünü Değiştirme\n\n**Yeni Yöntem**\n\n**Go modules** sayesinde Go 1.11'den beri artık GOPATH kullanmak zorunda değilsiniz. Aşağıdaki adımı herhangi bir klasörde kullanarak modülünüzü tanımlayabilirsiniz.\n\n```bash\ngo mod init github.com/{your-user}/{your-repo}\n```\n\n* Bu komutla o dizinde bir modül kökü oluşturulur.\n* İstediğiniz kadar modül oluşturabilirsiniz.\n\n**Eski Yöntem**\n\n**GOPATH** ile çalışmakta ısrar ediyorsanız aşağıdaki uyarılara dikkat etmelisiniz.\n\n* Go 1.8'den beri, GOPATH veya GOROOT'unuzu ayarlamanız gerekmez.\n* GOPATH varsayılan olarak **user/home** dizininizin altındadır.\n\n{% hint style=\"info\" %}\nGOPATH ayarlanmadıysa, Unix sistemlerinde $HOME/go ve Windows'ta `%USERPROFILE%\\go` olduğu varsayılır. Çalışma alanınız olarak özel bir konum kullanmak istiyorsanız, GOPATH ortam değişkenini ayarlayabilirsiniz.\n{% endhint %}\n\nÖzel çalışma alanı ayarlamak için aşağıdaki komutları kullanabilirsiniz.\n\n```bash\nexport GOROOT=/usr/lib/go\nexport GOPATH=$HOME/go\nexport PATH=$PATH:$GOROOT/bin:$GOPATH/bin\n```\n" }, { "path": "boeluem-1/golang-hakkinda.md", "content": "# Golang Hakkında\n\nGolang (diğer adıyla Go), **Google**’ın **2007** yılından beri geliştirdiği açık kaynaklı programlama dilidir. Daha çok alt-sistem programlama için tasarlanmış olup, derlenebilir ve **statik** tipli bir dildir. İlk versiyonu **Kasım 2009**‘da çıkmıştır. Derleyicisi olan **“gc” (Go Compiler)** açık kaynak olarak birçok işletim sistemi için geliştirilmiştir.\n\nGolang, Google mühendislerinden olan **Robert Griesemer, Rob Pike ve Ken Thompson** tarafından ilk olarak deney amaçlı ortaya çıkmıştır. Diğer dillerdeki eleştirilen sorunlara çözüm getirmek ve iyi yönlerini korumak için çıkarılmıştır.\n\nBu adamların daha önceden bulunmuş olduğu projelere bakacak olursak Google’ın gerçekten bu kişileri cımbızla seçtiğini anlayabiliriz. İşte Golang’ın yaratıcılarının bulunduğu projeler:\n\n| ![Ken Thompson](../.gitbook/assets/ken.png) | ![](https://blobscdn.gitbook.com/v0/b/gitbook-28427.appspot.com/o/assets%2F-LzCwvXTkWXBKIvbtzHZ%2F-LzDHbwlJmPgsn4Tr4UZ%2F-LzDIhOVf5\\_XFkT90LKM%2Frob.jpg?alt=media\\&token=c11be5e1-d017-4f10-b361-953ee37b1ca2) | ![](../.gitbook/assets/robert.png) |\n| :-----------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------: |\n| Ken Thompson | Rob Pike | Robert Griesemer |\n\n**Robert Griesemer:** Hotspot ve JVM (Java Sanal Makinesi)\n\n**Rob Pike:** UNIX ve UTF-8\n\n**Ken Thompson:** B, C, UNIX ve UTF-8\n\n**Dilin Özellikleri**\n\n* Statik yazılmıştır, fakat dinamik rahatlığındadır.\n* Büyük sistemlere ölçeklenebilir.\n* Üretken ve okunabilir olması, çok fazla zorunlu anahtar kelime ve tekrarlamaların kullanılmaması\n* Tümleşik Geliştirme Ortamına (IDE) ihtiyaç duyulmaması fakat desteklemesi\n* Ağ ve çoklu işlemleri desteklemesi\n* Değişken tanımında tür belirtimi isteğe bağlıdır.\n* Hızlı derlenme süresi\n* Uzak paket yöneticisi (go get)\n\n**Örnek Merhaba Dünya Uygulaması**\n\n```go\n package main\n\n import \"fmt\"\n\n func main(){\n fmt.Println(\"Merhaba Dünya!\")\n }\n```\n" }, { "path": "boeluem-1/iliskisel-operatoerler.md", "content": "# İlişkisel Operatörler\n\nİlişkisel operatörler programlamada iki veriyi birbiriyle karşılaştırabilmemize olanak sağlar. Karşılaştırma doğrulanıyorsa **true** değer, doğrulanmıyorsa **false** değer alır.\n\n| Operatör | Açıklama | Örnek |\n| -------- | -------------------------------------------------------- | ----- |\n| == | İki verinin eşitliği | 2==2 |\n| != | İki verinin eşitsizliği | 2!=3 |\n| > |
  1. verinin 2. veriden büyüklüğü
| 5>3 |\n| < |
  1. verinin 2. veriden küçüklüğü
| 4<6 |\n| >= |
  1. verinin 2. veriden büyük veya eşitliği
| 4>=6 |\n| <= |
  1. verinin 2. veriden küçük veya eşitliği
| 3<=8 |\n" }, { "path": "boeluem-1/klasoer-build-etme.md", "content": "# Klasör Build Etme\n\nOluşturduğumuz **.go** dosyaları birden fazla parçadan oluşuyorsa aşağıdaki komut ile klasör içerisindeyken build işlemini yapabiliriz.\n\n`go build . //sonda nokta işareti var`\n\nEğer klasörün dışından build işlemi yapacaksak nokta yerine klasörün yolunu girmemiz gerekir. Aşağıda gösterilmiştir.\n\nBuild işleminde sadece **.go** dosyaları derlenir. Tüm dosyalar işlenip tek başına çalıştırılabilir dosyaya dönüştürülür. Yani yanındaki Html, Css, Js vs. türünde dosyalar paket içine alınmaz. Tümüyle dosyları paketlemek için ek kütüphaneler kullanabilirsiniz. Önerim **Statik** isimli kütüphanedir. İlerideki bölümlerde zaten bu kütüphaneyi kullanıyor olacağız.\n\n`go build /klasör/yolunu/buraya/girin`\n" }, { "path": "boeluem-1/kod-gruplama-islemi.md", "content": "# Kod Gruplama İşlemi\n\nKod gruplama işlemi çok basit bir işlemdir. Bu işlem sayesinde aynı objeler bloklara göre farklı çalışabilir. Kodları gruplama için süslü parantez kullanırız. Örneğimizi görelim.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n değişken := \"bir\"\n {\n değişken := \"iki\"\n fmt.Println(değişken)\n }\n fmt.Println(değişken)\n}\n```\n\nÇıktımızı gördükten sonra kodları açıklayayım.\n\n> iki\n>\n> bir\n\nYukarıda **değişken** isminde değişken oluşturduk. Hemen aşağısına süslü parantez oluşturduk. İçine yine değişken adında bir değişken tanımladık. Bu iki değişken aynı kod bloğunda bulunmadığı için birbirleri ile alakası olmayacaktır. Aslında ikisi de aynı değişkendir. Sadece içindeki bloğa göre farklı bir değeri vardır. Bunu anlamanın en basit yolu pointer ile bellek adresine bakmaktır. Şimdi de örneğimizin o versiyonunu görelim.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n değişken := \"bir\"\n {\n değişken := \"iki\"\n fmt.Println(değişken)\n fmt.Println(&değişken)\n }\n fmt.Println(değişken)\n fmt.Println(&değişken)\n}\n```\n\n**& (and)** işareti ile değişkenin bellekteki adresini öğrenebiliriz.\n\nÇıktımız şöyle olacaktır;\n\n> iki\n>\n> 0xc00008c1d0\n>\n> bir\n>\n> 0xc00008c1c0\n\nGördüğünüz gibi bellek adresi 2 sonuçta da farklı gözüküyor. Bu ikisinin de ayrı değişkenler olduğuna işaret ediyor.\n" }, { "path": "boeluem-1/mantiksal-operatoerler.md", "content": "# Mantıksal Operatörler\n\nMantıksal operatörler birden fazla mantıksal veriyi kontrol eder ve kullandığımız operatöre göre mantıksal değer döndürür.\n\n| Operatör | Açıklama | Örnek |\n| -------- | ------------------------------------------------------------------------ | --------------------- |\n| && | VE operatörüdür. 2 koşulda doğruysa true değer verir | 2==2 && 2==3 (false) |\n| \\|\\| | VEYA operatörüdür. 2 koşuldan ikisi veya biri doğru ise true değer verir | 2==2 \\|\\| 2==3 (true) |\n| ! | DEĞİL operatörüdür. Koşul sonucunun tersini verir | !(2==2) (false) |\n" }, { "path": "boeluem-1/merhaba-duenya.md", "content": "# Merhaba Dünya\n\nProgramlama dünyasında gelenektir, bir programlama dili öğrenilirken ilk önce ekrana **“Merhaba Dünya”** çıktısı veren bir program yazılır. Biz de geleneği bozmadan Golang üzerinde Merhaba Dünya uygulaması yazalım.\n\nİlk önce kodları görelim. Daha sonra açıklamasını görelim.\n\n{% code title=\"main.go dosyası\" %}\n```go\npackage main\n\nimport “fmt”\n\nfunc main(){\n fmt.Println(“Merhaba Dünya!”)\n}\n```\n{% endcode %}\n\nŞimdi yukarıdaki kodlarda neler yaptığımıza gelelim.\n\n**Package**, kod sayfalarımız arasında iletişimde bulunabilmemizi sağlar. Bu sayede içerisinde **package** değeri aynı olan kod sayfaları birbirleriyle iletişim halinde olma yeteneği kazanır. Yukarıdaki örnekte package uygulama olan sayfalar birbiriyle iletişim kurabilir.\n\n**import “fmt”** ile Golang dilinde kullanılan ana işlemler için olan kütüphanemizi içeri aktardık.\n\n**func main()** ise programımızın çalışacağı ana bölümün fonksiyonudur. Yanındaki süslü parantezler { } içine yazdığımız kodlar ile programımızda çeşitli işlemler yapabileceğiz. Derlenmiş bir uygulama ilk olarak **main** fonksiyonuna bakar ve buradaki kodları çalıştırır.\n\nYukarıda **import** ettiğimiz **fmt** kütüphanesi içinden **Println** fonksiyonu ile ekranımıza **“Merhaba Dünya”** yazısını bastırdık. Gelelim programımızın derlenmesine. Daha önceden programlama dilleriyle geçmişi olmayan arkadaşlarımız için derlenme şöyle anlatılabilir. Yazdığımız Golang dili insanların kolaylıkla programlama yapabilmesi için oluşturulmuş bir dildir.\n\nAma makine (bilgisayar) bu yazdıklarımızı anlamaz. O yüzden her derlenen dilde olduğu gibi Golang’ın da yazdıklarımızı makinenin anlayacağı makine diline çeviren derleyicisi vardır.\n\nMakinemiz üzerinde çalıştırılabilir bir dosya üretmek için kodlarımızın derlenmesi gereklidir. Vscode üzerinden kodlarımızın derlenip çalışması için **F5** tuşuna basıyoruz. Böylece programımızı test edebiliriz. Eğer vscode üzerinden derliyorsanız yazdığımız kodların hemen altında **DEBUG CONSOLE** bölümünde kodumuzun sonuç çıktısını görebiliriz.\n\nÇıktımızı inceleyecek olursak, **API server listening at :127.0.0.1:44830** ibaresinde gerçekleşen olay, Golang kodlarımızı çalıştırdığımızda oluşturulan **44830** portlu **127.0.0.1** yerel sunucusu (localhost) üzerinden kodlarımızın sürüş testini gerçekleştirdik. Hemen aşağısına da çıktımızı verdi.\n\nEğer vscode üzerinden değil de, konsol üzerinden yapmak isterseniz, oluşturmuş olduğumuz main.go dosyasının bulunduğu dizin (klasör) içerisinde konsol uygulamamızı açıyoruz. Windows’ta cmd veya Powershell’dir. Unix sistemlerde terminal diye geçer. İki tarafa da yazacağımız komutlar aynıdır. O yüzden hangisinden yazdığınız farketmez.\n\nKodlarımızı sadece denemek istiyorsak yazacağımız komut::\n\n`go run main.go //main.go yerine .go dosyamızın ismi gelecek`\n\nEğer çalıştırılabilir bir dosya oluşturmak istiyorsak (Windows’ta .exe)\n\n`go build main.go //main.go yerine .go dosyamızın ismi gelecek`\n\nBöylece bu işlemleri yaptığımız dizin içerisine çalıştırılabilir bir dosya oluşturmuş olduk.\n\nWindows üzerinden konsola **main** yazarak uygulamayı açabilir veya klasörde **main.exe** dosyasına çift tıklayarak uygulamayı çalıştırabilirsiniz.\n\nLinux üzerinden ise terminale derlenmiş main çıktınızın bulunduğu dizinde **./main** yazarak çalıştırabilirsiniz.\n\nBöylece ilk uygulamamızı yazmış olduk. Tabi şu ana kadar görmemiş olduğumuz kodlar gördük. Onların açıklamaları da ileriki bölümlerde olacak. Şimdilik gelenek diye ilk bölümde **Merhaba Dünya** uygulaması yazdık.\n" }, { "path": "boeluem-1/paketler.md", "content": "# Paketler\n\nHer Golang programı paketlerden oluşur ve kendisi de bir pakettir.\n\n```go\npackage uygulama\n\nimport \"fmt\"\n\nfunc main() {\n fmt.Println(\"Merhaba Dünya\") // Çıktımız\n}\n```\n\n**package** terimi ile programımızın paket adını belirleriz. Hemen aşağısında da **import “fmt”** ile **fmt** paketini çektiğimizi görebilirsiniz. Yani çektiğimiz fmt paketi de bir programdır. Bilin bakalım fmt paketinin ilk satırında ne yazıyor? Tabiki de **package fmt**. Yani package ile programımızın ismini tanımlıyoruz. Bu ismi kullanarak diğer paketler ile iletişimde bulunabiliriz.\n\n**import** terimi ise yazıldığı pakete başka bir paketten bir yetenek aktarmaya yarar. Yetenekten kastım, import edilen paketin içinde fonksiyonlar mı var? Struct’lar mı var? vs. onları içeri aktarır.\n\n```go\nimport (\n “fmt”\n ”math”\n)\n```\n\nYukarıda birden fazla paket import etmeyi görüyoruz. **math** paketi bize ileri matematiksel işlemler yapabilmemiz için gerekli fonksiyonları sağlar.\n" }, { "path": "boeluem-1/sabitler.md", "content": "# Sabitler\n\nSabitler de değişkenler gibi değer alır. Fakat adından da anlaşılabileceği üzere verilen değer daha sonradan değiştirilemez.\n\nSabitler tanımlanırken başına const eklenir. Örnek olarak;\n\n```go\nconst isim string = “Ali”\nconst isim=”Veli”\n```\n\n{% hint style=\"danger\" %}\n**const** ile **:=** beraber kullanılamaz.\n\nYanlış kullanım: **const isim := “Ali”**\n\nDoğru kullanım: **const isim = “Ali”**\n{% endhint %}\n\nÖrnek olarak bir sabitin değerini atandıktan sonra değiştirmeye çalışalım. Aramızda ne olacağını merak eden çılgınlar olabilir.\n\nBu şekilde yazıp kodlarımızı derlediğimizde hata almamız kaçınamaz. Derlediğimizde **cannot assign to isim** hatasını verecektir. Yani diyor ki **isim’e atanamıyor**.\n\n```go\nconst isim string = “Ali”\nisim = “Ali”\nconst yas = 20\n```\n" }, { "path": "boeluem-1/sikca-sorulan-sorular.md", "content": "# Sıkça Sorulan Sorular\n\n{% hint style=\"info\" %}\n[https://golang.org/doc/faq](https://golang.org/doc/faq) adresindeki içerikten tercüme edilmiştir.\n{% endhint %}\n\n## 🔘 Kökenler\n\n### ➡️ Projenin amacı nedir?\n\nGo'nun başlangıcında, sadece on yıl önce, programlama dünyası bugünden farklıydı. Yazılım üretimi genellikle C ++ veya Java ile yapılıyordu.GitHub mevcut değildi. Çoğu bilgisayar henüz çok işlemcili değildi. Visual Studio ve Eclipse dışında, internette ücretsiz olarak birkaç IDE veya diğer üst düzey araçlar mevcuttu.\n\nBu arada, sunucu yazılımı geliştirmede birlikte çalıştığımız dilleri kullanmak için karşılaştığımız gereksiz karmaşıklıktan dolayı hayal kırıklığına uğradık. Bilgisayarlar, C, C ++ ve Java gibi diller ilk geliştirildiğinden beri çok daha hızlı hale gelmişti, ancak programlama eylemi tam olarak o kadar ilerlememişti. Ayrıca, çok işlemcinin evrensel hale geldiği açıktı, ancak çoğu dil onları verimli ve güvenli bir şekilde programlamak için çok az yardım sundu.\n\nBir adım geri gitmeye ve teknoloji geliştikçe önümüzdeki yıllarda yazılım mühendisliğine hangi önemli sorunların hâkim olacağını ve yeni bir dilin bunları nasıl çözebileceğini düşünmeye karar verdik. Örneğin, çok çekirdekli CPU'ların yükselişi, bir dilin bir tür eşzamanlılık veya paralellik için birinci sınıf destek sağlaması gerektiğini savundu. Buna mütakiben kaynak yönetimini büyük bir eşzamanlı programda izlenebilir hale getirmek için, çöp toplama veya en azından bir tür güvenli otomatik bellek yönetimi gerekliydi.\n\nBu düşünceler, Go'nun önce bir dizi fikir ve aranan veri, sonra da bir dil olarak ortaya çıktığı bir dizi tartışmaya yol açtı. Kapsamlı bir hedef, Go'nun çalışan programcıya takım oluşturmayı etkinleştirerek, kod biçimlendirme gibi sıradan görevleri otomatikleştirerek ve büyük kod tabanlarında çalışmanın önündeki engelleri kaldırarak daha fazla yardım etmesiydi.\n\nGo'nun hedeflerinin ve bunlara nasıl ulaşıldığının veya en azından bunlara nasıl yaklaşıldığının çok daha kapsamlı bir açıklaması [Go at Google: Language Design in the Service of Software Engineering](https://talks.golang.org/2012/splash.article) adlı makalede mevcuttur.\n\n### ➡️ Projenin tarihçesi nedir?\n\nRobert Griesemer, Rob Pike ve Ken Thompson 21 Eylül 2007'de beyaz tahtada yeni bir dilin hedeflerini çizmeye başladılar. Birkaç gün içinde hedefler bir şeyler yapma planına ve bunun ne olacağına dair adil bir fikre yerleşti. Tasarım, ilgisiz çalışmaya paralel olarak yarı zamanlı devam etti. Ocak 2008'de Ken, fikirleri araştırmak için bir derleyici üzerinde çalışmaya başladı; çıktı olarak C kodunu üretti. Yıl ortasına gelindiğinde, dil tam zamanlı bir proje haline geldi ve bir üretim derleyicisini deneyecek kadar yerleşti. Mayıs 2008'de Ian Taylor, taslak şartnameyi kullanarak Go için bir GCC ön ucunu bağımsız olarak kullanmaya başladı. Russ Cox 2008'in sonlarında katıldı ve dilin ve kitaplıkların prototipten gerçeğe taşınmasına yardımcı oldu.\n\nGo, 10 Kasım 2009'da halka açık bir açık kaynak projesi oldu. Topluluktan sayısız kişi fikirlere, tartışmalara ve kodlara katkıda bulundu.\n\nŞu anda dünya çapında milyonlarca Go programcısı (gopher) var ve her gün daha fazlası var olacak. Go'nun başarısı beklentilerimizi çok aştı.\n\n### ➡️ Gopher maskotu nereden geliyor?\n\nMaskot ve logo, Plan 9 tavşanı [Glenda](https://9p.io/plan9/glenda.html)'yı da tasarlayan [Renée French](https://reneefrench.blogspot.com/) tarafından tasarlandı. Gopher hakkında bir [blog yazısı](https://blog.golang.org/gopher), birkaç yıl önce bir [WFMU](https://wfmu.org/) tişört tasarımı için kullandığı birinden nasıl türetildiğini açıklıyor. Logo ve maskot, [Creative Commons Attribution 3.0 lisansı](https://creativecommons.org/licenses/by/3.0/) kapsamındadır. Gopher, özelliklerini ve bunların doğru şekilde nasıl temsil edileceğini gösteren bir [model sayfası](https://golang.org/doc/gopher/modelsheet.jpg)na sahiptir. Model sayfası ilk olarak 2016 yılında Renée'nin Gophercon'da yaptığı bir [konuşma](https://www.youtube.com/watch?v=4rw\\_B4yY69k)da gösterildi. Kendine özgü özellikleri var; o Go gopher, herhangi bir yaşlı sincap değil.\n\n### ➡️ Dilin adı Go mu Golang mi?\n\nDilin adı Go. \"Golang\" takma adının ortaya çıkmasının nedeni, web sitesinin bizim için mevcut olmayan go.org değil, [golang.org](https://golang.org/) olmasıdır. Yine de çoğu golang adını kullanır ve etiket olarak kullanışlıdır. Örneğin, dil için Twitter etiketi \"#golang\" dir. Dilin adı ne olursa olsun sadece Go'dur.\n\n**Bir yan not:** [Resmi logo](https://blog.golang.org/go-brand)nun iki büyük harfi olmasına rağmen, dil adı GO değil, Go yazılmıştır.\n\n### ➡️ Neden yeni bir dil yarattınız?\n\nGo, Google'da yaptığımız iş için mevcut diller ve ortamlarla ilgili hayal kırıklığından doğdu. Programlama çok zor hale geldi ve dil seçimi kısmen suçluydu. Etkili derlemeyi, verimli yürütmeyi veya programlama kolaylığını seçmek gerekiyordu; üçü de aynı ana dilde mevcut değildi. C ++ veya daha az ölçüde Java yerine Python ve JavaScript gibi dinamik olarak yazılmış dillere geçerek güvenlik ve verimlilik üzerinde kolaylık seçebilmeliydi programcılar.\n\nEndişelerimizde yalnız değildik. Yıllar sonra, programlama dilleri için oldukça sessiz bir manzaraya sahip olan Go, programlama dili geliştirmeyi tekrar aktif, neredeyse yaygın bir alan haline getiren birkaç yeni dilin (Rust, Elixir, Swift ve daha fazlası) ilklerinden biriydi.\n\nGo, yorumlanmış, dinamik olarak yazılmış bir dilin programlama kolaylığını statik olarak yazılmış, derlenmiş bir dilin verimliliği ve güvenliğiyle birleştirmeye çalışarak bu sorunları ele aldı. Bu dil aynı zamanda ağa bağlı ve çok çekirdekli bilgi işlem desteğiyle modern olmayı hedefliyordu. Son olarak, Go ile çalışmanın hızlı olması amaçlanmıştır: Tek bir bilgisayarda büyük bir yürütülebilir dosya oluşturmak en fazla birkaç saniye sürecektir. Bu hedeflere ulaşmak için bir dizi dilbilimsel konuyu ele almak gerekiyor: ifade edici ama hafif bir yazım sistemi; eşzamanlılık ve çöp toplama; katı bağımlılık belirtimi; ve bunun gibi. Bunlar kütüphaneler veya araçlar tarafından iyi bir şekilde ele alınamaz; yeni bir dil aranıyordu.\n\n[Go at Google](https://talks.golang.org/2012/splash.article) makalesi, Go dilinin tasarımının arkasındaki arka planı ve motivasyonu tartışmanın yanı sıra bu SSS'de sunulan yanıtların çoğu hakkında daha fazla ayrıntı sağlar.\n\n### ➡️ Go'nun ataları nelerdir? (veya esinlendikleri)\n\nGo, çoğunlukla Pascal / Modula / Oberon ailesinden (bildirimler, paketler) önemli girdiler ve ayrıca Newsqueak ve Limbo (eşzamanlılık) gibi Tony Hoare'nin CSP'sinden esinlenen dillerden bazı fikirlerle, C ailesinde (temel sözdizimi) bulunur. Ancak, her yerde yeni bir dildir. Her açıdan dil, programcıların ne yaptığını ve programlamayı nasıl yapacağını, en azından yaptığımız programlama türünü, daha etkili, yani daha eğlenceli olması düşünülerek tasarlandı.\n\n### ➡️ Tasarımda yol gösterici ilkeler nelerdir?\n\nGo tasarlandığında, Java ve C ++, en azından Google'da, sunucuları yazmak için en yaygın kullanılan dillerdi. Bu dillerin çok fazla defter tutma (muhasebecilik) ve tekrarlama gerektirdiğini hissettik. Bazı programcılar, verimlilik ve yazım güvenliği pahasına Python gibi daha dinamik, akıcı dillere geçerek tepki gösterdi. Verimliliğe, güvenliğe ve akıcılığa tek bir dilde sahip olmanın mümkün olması gerektiğini hissettik.\n\nGo, kelimenin her iki anlamında da yazma miktarını azaltmaya çalışır. Tasarımı boyunca dağınıklığı ve karmaşıklığı azaltmaya çalıştık. İleri tanımlamalar ve başlık (header) dosyaları yoktur; her şey tam olarak bir kez ilan edilir. Başlatma anlamlı, otomatik ve kullanımı kolaydır. Sözdizimi temiz ve anahtar kelimelerde hafiftir. Yazımda gereksizlik (foo.Foo \\* myFoo = new (foo.Foo)): = tanımla-ve-türet yapısı kullanılarak basit tür türetmesi ile azaltılır. Ve belki de en radikal olanı, tür hiyerarşisi yoktur: türler sadece ilişkilerdir. Bu basitleştirmeler, Go'nun etkileyici olmasına rağmen karmaşıklıktan ödün vermeden anlaşılabilir olmasını sağlar.\n\nBir diğer önemli ilke de kavramları ortogonal tutmaktır. Yöntemler her tür için uygulanabilir; yapılar (struct) verileri temsil ederken arayüzler (interface) soyutlamayı temsil eder. Ortogonallik, nesneler birleştiğinde ne olduğunu anlamayı kolaylaştırır.\n\n## 🔘 Kullanım\n\n### ➡️ Google, Go'yu dahili olarak kullanıyor mu?\n\nEvet. Go, Google içindeki üretimde yaygın olarak kullanılmaktadır. Bunun kolay bir örneği [golang.org](https://golang.org/)'un arkasındaki sunucudur. [Google App Engine](https://developers.google.com/appengine/)'de bir üretim yapılandırmasında çalışan godoc belge sunucusudur.\n\nDaha önemli bir örnek, Google'ın Chrome ikili (binary) dosyalarını ve apt-get (Debian paket yöneticisi oluyor kendisi) paketleri gibi diğer büyük yüklenebilir dosyaları sunan indirme sunucusu `dl.google.com`'dur.\n\nGo, Google'da kullanılan tek dil değildir, ancak site güvenilirliği mühendisliği (SRE) ve büyük ölçekli veri işleme dahil olmak üzere birçok alan için anahtar dildir.\n\n### ➡️ Başka hangi şirketler Go kullanıyor?\n\nGo kullanımı dünya çapında artıyor, ancak hiçbir şekilde yalnızca bulut bilişim alanında değil. Go'da yazılan birkaç büyük bulut altyapı projesi Docker ve Kubernetes'tir, ancak çok daha fazlası vardır.\n\nYine de sadece bulut değil. Go Wiki, Go kullanan birçok şirketin bazılarını listeleyen ve düzenli olarak güncellenen bir [sayfa](https://github.com/golang/go/wiki/GoUsers) içerir. Wiki'de ayrıca, dili kullanan şirketler ve projeler hakkındaki [başarı hikayeleri](https://github.com/golang/go/wiki/SuccessStories)ne bağlantılar içeren bir sayfa vardır.\n\n### ➡️ Go programları C / C ++ programlarıyla bağlantılı mı?\n\nC ve Go'yu aynı adres alanında birlikte kullanmak mümkündür, ancak bu doğal bir uyum değildir ve özel arayüz yazılımı gerektirebilir. Ayrıca, C'yi Go koduyla ilişkilendirmek, Go'nun sağladığı bellek güvenliği ve yığın yönetimi özelliklerinden mahrum kalmaktır. Bazen bir sorunu çözmek için C kitaplıklarını kullanmak kesinlikle gereklidir, ancak bunu yapmak her zaman saf Go kodunda bulunmayan bir risk unsuru getirir, bu yüzden dikkatli olun.\n\nC'yi Go ile kullanmanız gerekiyorsa, nasıl devam edeceğiniz Go derleyici uygulamasına bağlıdır. Go ekibi tarafından desteklenen üç Go derleyici uygulaması vardır. Bunlar, GCC arka ucunu kullanan varsayılan derleyici gccgo ve LLVM altyapısını kullanan biraz daha az olgun bir gollvm'dir.\n\nGc, C'den farklı bir arama kuralı ve bağlayıcı kullanır ve bu nedenle doğrudan C programlarından veya tam tersi şekilde çağrılamaz. [Cgo](https://golang.org/cmd/cgo/) programı, C kitaplıklarının Go kodundan güvenli bir şekilde çağrılmasına izin veren bir \"yabancı işlev arabirimi\" mekanizması sağlar. SWIG C ++ kitaplıklarına erişme yeteneğini genişletir.\n\nGccgo ve gollvm ile cgo ve SWIG'i de kullanabilirsiniz. Geleneksel bir API kullandıklarından, büyük bir dikkatle, bu derleyicilerden gelen kodu doğrudan GCC / LLVM-derlenmiş C veya C ++ programlarına bağlamak da mümkündür. Ancak, bunu güvenli bir şekilde yapmak, ilgili tüm diller için çağrı kurallarının anlaşılmasını ve ayrıca Go'dan C veya C ++ çağrılırken yığın sınırlarının dikkate alınmasını gerektirir.\n\n### ➡️ Hangi IDE'lerin Go desteği var?\n\nGo projesi özel bir IDE içermez, ancak dil ve kitaplıklar, kaynak kodunu analiz etmeyi kolaylaştıracak şekilde tasarlanmıştır. Sonuç olarak, en iyi bilinen editörler ve IDE'ler, doğrudan veya bir eklenti aracılığıyla Go destekler. İyi Go desteğine sahip tanınmış IDE'lerin ve editörlerin listesi Emacs, Vim, VSCode, Atom, Eclipse, Sublime, IntelliJ (Goland adlı özel bir varyant aracılığıyla) ve daha fazlasını içerir. En sevdiğiniz ortam, Go'da programlama için üretken bir ortam olabilir.\n\n### ➡️ Go, Google'ın protokol tamponlarını (buffers) destekliyor mu?\n\nAyrı bir açık kaynak projesi, gerekli derleyici eklentisini ve kitaplığı sağlar. [github.com/golang/protobuf/](https://github.com/golang/protobuf) adresinde mevcuttur.\n\n### ➡️ Go ana sayfasını başka bir dile çevirebilir miyim?\n\nKesinlikle. Geliştiricileri kendi dillerinde Go Language siteleri oluşturmaya teşvik ediyoruz. Ancak, sitenize Google logosunu veya markasını eklemeyi seçerseniz ([golang.org](https://golang.org/)'da görünmez), [www.google.com/permissions/guidelines.html](https://www.google.com/permissions/guidelines.html) adresindeki yönergelere uymanız gerekecektir.\n\n## 🔘 Tasarım\n\n### ➡️ Go çalışma zamanına (runtime) sahip mi?\n\nGo, her Go programının bir parçası olan, çalışma zamanı adı verilen kapsamlı bir kitaplığa sahiptir. Çalışma zamanı kitaplığı çöp toplama, eşzamanlılık, yığın yönetimi ve Go dilinin diğer kritik özelliklerini uygular. Dil için daha merkezi olmasına rağmen, Go'nun çalışma zamanı C kitaplığı olan `libc`'ye benzer.\n\nBununla birlikte, Go'nun çalışma zamanının Java çalışma zamanı tarafından sağlananlar gibi bir sanal makine içermediğini anlamak önemlidir. Go programları, yerel makine koduna (veya bazı varyant uygulamaları için JavaScript veya WebAssembly) önceden derlenir. Bu nedenle, terim genellikle bir programın çalıştığı sanal ortamı tanımlamak için kullanılsa da, Go'da \"çalışma zamanı\" kelimesi yalnızca kritik dil hizmetleri sağlayan kitaplığa verilen addır.\n\n### ➡️ Unicode tanımlayıcılarından n'aber?\n\nGo'yu tasarlarken aşırı ASCII merkezli olmadığından emin olmak istedik. Bu da tanımlayıcıların alanını 7 bitlik ASCII'nin sınırlarından genişletmek anlamına geliyordu. Go kuralı — tanımlayıcı karakterler Unicode tarafından tanımlandığı gibi harf veya rakam olmalıdır — anlaşılması ve uygulanması kolaydır, ancak kısıtlamaları vardır. Örneğin, karakterleri birleştirmek tasarım tarafından hariç tutulur ve bu, Devanagari gibi bazı dilleri hariç tutar.\n\nBu kuralın talihsiz bir sonucu daha var. Dışa aktarılan bir tanımlayıcının bir büyük harfle başlaması gerektiğinden, bazı dillerde karakterlerden oluşturulan tanımlayıcılar tanım gereği dışa aktarılamaz. Şimdilik tek çözüm, açıkça tatmin edici olmayan X 日本語 gibi bir şey kullanmaktır.\n\nDilin en eski sürümünden bu yana, diğer yerel dilleri kullanan programcıları barındırmak için tanımlayıcı alanının en iyi şekilde nasıl genişletilebileceği konusunda önemli ölçüde düşünülmüştür. Tam olarak ne yapılacağı aktif bir tartışma konusu olmaya devam ediyor ve dilin gelecekteki bir versiyonu tanımlayıcı tanımında daha liberal olabilir. Örneğin, Unicode organizasyonunun tanımlayıcılar için önerilerinden bazı fikirleri benimseyebilir. Ne olursa olsun, Go'nun en sevdiğimiz özelliklerinden biri olan harf durumunun tanımlayıcıların görünürlüğünü belirleme şeklini korurken (veya belki genişletirken) uyumlu bir şekilde yapılmalıdır.\n\n Şimdilik, daha sonra programları bozmadan genişletilebilecek basit bir kuralımız var. Belirsiz tanımlayıcıları kabul eden bir kuraldan kesinlikle kaynaklanabilecek hataları önleyen bir kural.\n\n### ➡️ Go neden X özelliğine sahip değil?\n\nHer dil yeni özellikler içerir ve birinin en sevdiği özelliği atlar. Go, programlamanın mutluluğu, derleme hızı, kavramların ortogonalitesi ve eşzamanlılık ve çöp toplama gibi özellikleri destekleme ihtiyacı göz önünde bulundurularak tasarlandı. En sevdiğiniz özellik, uymadığından, derleme hızını veya tasarımın netliğini etkilediği veya temel sistem modelini çok zorlaştıracağı için eksik olabilir.\n\nGo'nun X özelliğinin eksik olması sizi rahatsız ediyorsa, lütfen bizi affedin ve Go'nun sahip olduğu özellikleri araştırın. X'in eksikliğini ilginç yollarla telafi ettiklerini görebilirsiniz.\n\n### ➡️ Go'da neden jenerik tipler yok?\n\nJenerikler bir noktada eklenebilir. Bazı programcıların yaptığını bilsek de, onlar için bir aciliyet hissetmiyoruz.\n\nGo, zaman içinde bakımı kolay olacak sunucu programları yazmak için bir dil olarak tasarlandı. (Daha fazla arka plan için [bu makale](https://talks.golang.org/2012/splash.article)ye bakın.) Tasarım, ölçeklenebilirlik, okunabilirlik ve eşzamanlılık gibi şeylere odaklandı. Polimorfik programlama o zamanlar dilin hedefleri için gerekli görünmüyordu ve bu yüzden basitlik için dışarıda bırakıldı.\n\nDil artık daha olgundur ve bir tür genel programlamayı düşünmek için alan vardır. Ancak, bazı uyarılar var.\n\nJenerikler kullanışlıdır, ancak tip sistem ve çalışma süresinde karmaşıklık açısından bir maliyete sahiptirler. Karmaşıklığa orantılı değer veren bir tasarım henüz bulamadık, ancak üzerinde düşünmeye devam ediyoruz. Bu arada, Go'nun yerleşik haritaları (map) ve dilimlerinin (slice) yanı sıra konteynerler oluşturmak için boş arayüzü kullanma yeteneği (açık kutudan çıkarma ile), çoğu durumda kod yazmanın mümkün olduğu anlamına gelir. Bu, daha az sorunsuz olsa da jeneriklerin sağlayacağı şeyi yapar.\n\nKonu açık kalır. Go için iyi bir jenerik çözüm tasarlamaya yönelik önceki birkaç başarısız girişime bir göz atmak için [bu öneriye](https://golang.org/issue/15292) bakın.\n\n### ➡️ Neden Go'da Exceptions yok?\n\nTry-catch-final deyiminde olduğu gibi bir kontrol yapısına istisnaların birleştirilmesinin kıvrımlı kodla sonuçlandığına inanıyoruz. Ayrıca, programcıları, bir dosyayı açamama gibi çok fazla sıradan hatayı istisnai olarak etiketlemeye teşvik etme eğilimindedir.\n\nGo farklı bir yaklaşım sergiliyor. Düz hata işleme için, Go'nun çoklu değer dönüşleri, dönüş değerini aşırı yüklemeden bir hatayı bildirmeyi kolaylaştırır. [Go'nun diğer özellikleriyle birlikte kanonik bir hata türü](https://golang.org/doc/articles/error\\_handling.html), hata işlemeyi keyifli hale getirir ancak diğer dillerdekinden oldukça farklıdır.\n\nGo ayrıca, gerçekten istisnai koşullardan sinyal almak ve kurtarmak için birkaç yerleşik işleve sahiptir. Kurtarma mekanizması, yalnızca bir hatadan sonra yıkılan bir işlevin durumunun bir parçası olarak yürütülür; bu, felaketi ele almak için yeterlidir, ancak ekstra kontrol yapıları gerektirmez ve iyi kullanıldığında temiz hata işleme koduyla sonuçlanabilir. Ayrıntılar için [Defer, Panic ve Recover makalesi](https://golang.org/doc/articles/defer\\_panic\\_recover.html)ne bakın. Bu dökümanda ise şu konulara bakabilirsiniz.\n\n{% content-ref url=\"../boeluem-2/defer.md\" %}\n[defer.md](../boeluem-2/defer.md)\n{% endcontent-ref %}\n\n{% content-ref url=\"../boeluem-5/panic-and-recover.md\" %}\n[panic-and-recover.md](../boeluem-5/panic-and-recover.md)\n{% endcontent-ref %}\n\nAyrıca, [Hatalar blog gönderisi](https://blog.golang.org/errors-are-values)nin bir Go'da hataları temiz bir şekilde işleme yaklaşımı, hataların sadece değerler olduğundan, Go'nun tam gücünün hata işlemede kullanılabileceğini göstererir.\n\n### ➡️ Go'da neden assertions (iddialar) yok?\n\nGo, assertions sağlamaz. İnkar edilemez derecede kullanışlıdırlar, ancak bizim deneyimlerimiz, programcıların bunları doğru hata işleme ve raporlama hakkında düşünmekten kaçınmak için koltuk değneği olarak kullanmasıdır. Doğru hata işleme, sunucuların önemli olmayan bir hatadan sonra çökmek yerine çalışmaya devam etmesi anlamına gelir. Doğru hata raporlama, hataların doğrudan ve yerinde olduğu anlamına gelir ve programcıyı büyük bir çökme izini yorumlamaktan kurtarır. Hataları gören programcı koda aşina olmadığında kesin hatalar özellikle önemlidir.\n\nBunun bir çekişme noktası olduğunu anlıyoruz. Go dilinde ve kütüphanelerde modern uygulamalardan farklı birçok şey vardır, çünkü bazen farklı bir yaklaşımın denemeye değer olduğunu düşünüyoruz.\n\n### ➡️ Neden CSP fikirleri üzerine eşzamanlılık inşa etmelisiniz?\n\nEşzamanlılık ve çok iş parçacıklı programlama, zaman içinde zorluklarla ilgili bir ün geliştirmiştir. Bunun kısmen [pthreads](https://en.wikipedia.org/wiki/POSIX\\_Threads) gibi karmaşık tasarımlardan ve kısmen de mutexler, koşul değişkenleri ve bellek engelleri gibi düşük seviyeli ayrıntılara aşırı vurgu yapılmasından kaynaklandığına inanıyoruz. Daha yüksek seviyeli arayüzler, kapakların altında hala mutexler ve benzeri şeyler olsa bile çok daha basit bir kod sağlar.\n\nEşzamanlılık için üst düzey dil desteği sağlamanın en başarılı modellerinden biri, Hoare'nin İletişim Sıralı Süreçlerinden veya CSP'den gelir. Occam ve Erlang, CSP'den kaynaklanan iki iyi bilinen dildir. Go'nun eşzamanlılık ilkelleri, ana katkısı birinci sınıf nesneler olarak güçlü kanal kavramı olan aile ağacının farklı bir bölümünden türemiştir. Daha önceki birkaç dil ile ilgili deneyimler, CSP modelinin bir prosedürel dil çerçevesine çok iyi uyduğunu göstermiştir.\n\n### ➡️ Neden Thread yerine Goroutine?\n\nGoroutinler, eşzamanlılığın kullanımını kolaylaştırmanın bir parçasıdır. Bir süredir ortalıkta olan fikir, işlevleri - koroutinleri - bağımsız olarak bir dizi iş parçacığına çoğaltmaktır. Bir coroutine bloke edildiğinde, örneğin bir bloke edici sistem çağrısını çağırarak bloke edildiğinde, çalışma zamanı aynı işletim sistemi iş parçacığındaki diğer koroutinleri otomatik olarak farklı, çalıştırılabilir bir iş parçacığına taşır, böylece bunlar engellenmez. Programcı bunların hiçbirini görmez, önemli olan budur.\n\nGorutinler dediğimiz sonuç çok ucuz olabilir: sadece birkaç kilobayt olan yığın hafızasının ötesinde çok az ek yüke sahiptirler. Yığınları küçültmek için Go'nun çalışma zamanı yeniden boyutlandırılabilir, sınırlı yığınlar kullanır. Yeni basılmış bir gorutine birkaç kilobayt verilir ve bu neredeyse her zaman yeterlidir. Değilse, çalışma zamanı yığını otomatik olarak depolamak için belleği büyütür (ve küçültür), böylece birçok gorutinin mütevazı bir bellek miktarında yaşamasına izin verir. CPU ek yükü, işlev çağrısı başına yaklaşık üç ucuz talimatın ortalamasını alır. Bu aynı adres alanında yüz binlerce gorutin oluşturmak için pratik. Gorutinler sadece iş parçacıkları olsaydı, sistem kaynakları çok daha az sayıda tükenirdi.\n\n### ➡️ Map işlemleri neden atomik olarak tanımlanmıyor?\n\nUzun tartışmalardan sonra, haritaların tipik kullanımının birden fazla gorutinden güvenli erişim gerektirmediğine karar verildi ve bu durumlarda, map muhtemelen zaten senkronize edilmiş daha büyük bir veri yapısının veya hesaplamanın bir parçasıydı. Bu nedenle, tüm map işlemlerinin bir mutex yakalamasını gerektirmek çoğu programı yavaşlatır ve birkaçına güvenlik ekler. Kontrolsüz map erişiminin programı çökertebileceği anlamına geldiğinden, bu kolay bir karar değildi.\n\nDil, atomik map güncellemelerini engellemez. Güvenilmeyen bir programı barındırırken olduğu gibi gerektiğinde, uygulama map erişimini birbirine bağlayabilir.\n\nMap erişimi, yalnızca güncellemeler yapılırken güvenli değildir. Tüm gorutinler yalnızca okuduğu - range için döngü (for) kullanarak yineleme dahil map'teki öğeleri aradığı ve öğelere atayarak veya silme işlemleri yaparak map'i değiştirmediği sürece, map'e eşzamanlı olarak erişmeleri güvenlidir.\n\nMap kullanımının düzeltilmesine yardımcı olarak, bazı Dil uygulamaları, bir map eşzamanlı yürütmeyle güvenli olmayan bir şekilde değiştirildiğinde çalışma zamanında otomatik olarak rapor veren özel bir denetim içerir.\n\n### ➡️ Dil değişikliğimi kabul edecek misiniz?\n\nİnsanlar genellikle dilde iyileştirmeler yapılmasını önerir - [posta listesi](https://groups.google.com/group/golang-nuts) bu tür tartışmaların zengin bir geçmişini içerir - ancak bu değişikliklerin çok azı kabul edilmiştir. Go açık kaynaklı bir proje olmasına rağmen, dil ve kitaplıklar, en azından kaynak kodu düzeyinde mevcut programları bozan değişiklikleri önleyen bir uyumluluk vaadi ile korunmaktadır (programların güncel kalması için ara sıra yeniden derlenmesi gerekebilir). Öneriniz Go 1 spesifikasyonunu ihlal ederse, değeri ne olursa olsun fikri dikkate alamayız bile.\n\nGo'nun gelecekteki büyük bir sürümü Go 1 ile uyumsuz olabilir, ancak bu konuyla ilgili tartışmalar daha yeni başladı ve kesin olan bir şey var: süreçte ortaya çıkan bu tür uyumsuzluklar çok az olacak. Dahası, uyumluluk vaadi, eski programların bu durum ortaya çıktığında adapte olması için ileriye dönük otomatik bir yol sağlamaya bizi teşvik ediyor. Teklifiniz Go 1 spesifikasyonuyla uyumlu olsa bile, Go'nun tasarım hedeflerinin ruhuna uygun olmayabilir. [Google'da Go: Yazılım Mühendisliği Hizmetinde Dil Tasarımı](https://talks.golang.org/2012/splash.article), Go'nun kökenlerini ve tasarımının arkasındaki motivasyonu açıklıyor.\n\n## 🔘 Türler\n\n### ➡️ Go nesne yönelimli bir dil midir?\n\nEvet ve hayır. Go'nun türleri ve yöntemleri olmasına ve nesneye yönelik bir programlama stiline izin vermesine rağmen, tür hiyerarşisi yoktur. Go'daki \"interface\" kavramı, kullanımının kolay ve bazı açılardan daha genel olduğuna inandığımız farklı bir yaklaşım sağlar. Alt sınıflara benzer - ancak aynı olmayan - bir şey sağlamak için diğer türlere türleri gömmenin yolları da vardır. Dahası, Go'daki yöntemler C ++ veya Java'dakinden daha geneldir: düz, \"unboxed\" tamsayılar gibi yerleşik türler dahil her tür veri için tanımlanabilirler. Yapılar (sınıflar) ile sınırlı değildirler.\n\nAyrıca, bir tür hiyerarşisinin olmaması, Go'daki \"nesnelerin\" C ++ veya Java gibi dillerden çok daha hafif hissetmesini sağlar.\n\n### ➡️ Yöntemlerin dinamik gönderimini nasıl edinebilirim?\n\nYöntemleri dinamik olarak göndermenin tek yolu bir interface kullanmaktır. Bir yapı veya başka herhangi bir somut türdeki yöntemler her zaman statik olarak çözümlenir.\n\n### ➡️ Neden tür mirası (kalıtım) yok?\n\nNesne yönelimli programlama, en azından en iyi bilinen dillerde, türler arasındaki ilişkilerin, genellikle otomatik olarak türetilebilen ilişkilerin çok fazla tartışılmasını içerir. Go farklı bir yaklaşım benimser.\n\nGo'da programcının önceden iki türün ilişkili olduğunu bildirmesini istemek yerine, Go'da bir tür, yöntemlerinin bir alt kümesini belirten herhangi bir interface'i otomatik olarak tatmin eder. Muhasebe tutmayı azaltmanın yanı sıra, bu yaklaşımın gerçek avantajları vardır. Türler, geleneksel çoklu kalıtımın karmaşıklıkları olmaksızın birçok arabirimi aynı anda karşılayabilir. Arayüzler çok hafif olabilir — bir hatta sıfır metotlu bir arayüz faydalı bir kavramı ifade edebilir. Arayüzler, yeni bir fikir ortaya çıkarsa veya test için orijinal tiplere açıklama yapmadan eklenebilir. Türler ve arabirimler arasında açık ilişkiler olmadığından, yönetilecek veya tartışılacak tür hiyerarşisi yoktur. Bu fikirleri benzer bir şey inşa etmek için kullanmak mümkündür. Örneğin, fmt.Fprintf'in sadece bir dosyaya değil herhangi bir çıktıya biçimlendirilmiş yazdırmayı nasıl sağladığını veya bufio paketinin dosya G / Ç'sinden nasıl tamamen ayrı olabileceğini veya görüntü paketlerinin sıkıştırılmış görüntü dosyalarını nasıl oluşturduğunu görün.\n\nTüm bu fikirler, tek bir yöntemi (Yazma) temsil eden tek bir arayüzden (io.Writer) kaynaklanır. Ve bu sadece yüzeyi çizer. Go'nun arayüzlerinin, programların nasıl yapılandırıldığı üzerinde derin bir etkisi vardır. Alışmak biraz zaman alır, ancak bu örtük tip bağımlılığı Go ile ilgili en verimli şeylerden biridir.\n\n### ➡️ len() neden bir metod değilde fonksiyondur?\n\nBu konuyu tartıştık, ancak pratikte işlevler iyi olduğu için len ve arkadaşlarını uygulamaya koymaya karar verdik ve temel türlerin interface'i (Go türü anlamında) hakkındaki soruları karmaşıklaştırmadı.\n\n### ➡️ Go neden method ve operatör overloading desteklemiyor?\n\nTür eşleştirmesi de yapması gerekmiyorsa method gönderimi basitleştirilmiştir. Diğer dillerle edindiğimiz deneyimler bize, aynı isimde ancak farklı imzalara sahip çeşitli yöntemlere sahip olmanın bazen yararlı olduğunu, ancak pratikte kafa karıştırıcı ve kırılgan olabileceğini söyledi. Yalnızca isme göre eşleştirme ve türlerde tutarlılık gerektirme, Go'nun tür sisteminde büyük bir basitleştirici karardı. Operatörün aşırı yüklenmesi ile ilgili olarak, mutlak bir gereklilikten daha fazla bir kolaylık gibi görünüyor. Yine de, onsuz işler daha basit.\n\n### ➡️ Go neden \"uygular\" (implements) tanımlamalarına sahip değil?\n\nBir Go türü, o arayüzün metodlarını uygulayarak bir arayüzü tatmin eder, başka bir şey değil. Bu özellik, arayüzlerin mevcut kodu değiştirmeye gerek kalmadan tanımlanmasına ve kullanılmasına izin verir. Kaygıların ayrılmasını teşvik eden ve kodun yeniden kullanımını geliştiren ve kod geliştikçe ortaya çıkan kalıplar üzerine inşa etmeyi kolaylaştıran bir tür [yapısal yazım ](https://en.wikipedia.org/wiki/Structural\\_type\\_system)sağlar. Arayüzlerin anlamsallığı, Go'nun çevik ve hafif yapısının ana nedenlerinden biridir. Daha fazla ayrıntı için [tür mirası hakkındaki soru](https://golang.org/doc/faq#inheritance)ya bakın.\n\n### ➡️ Türümün bir arayüzü karşıladığını nasıl garanti edebilirim?\n\nDerleyiciden, uygun şekilde, T için sıfır değerini veya T'ye işaretçi kullanarak bir atama yaparak T türünün arayüzü I uygulayıp uygulamadığını kontrol etmesini isteyebilirsiniz:\n\n```go\ntype T struct{}\nvar _ I = T{} // T'nin I'ya tanımlandığını doğrulayın.\nvar _ I = (*T)(nil) // *T'nin I'ya tanımlandığını doğrulayın.\n```\n\nT (veya \\* T, buna göre) I'ya uygulamazsa, hata derleme zamanında yakalanacaktır. Bir arayüzün kullanıcılarının onu uyguladıklarını açıkça beyan etmelerini isterseniz, arayüzün yöntem kümesine açıklayıcı bir ada sahip bir yöntem ekleyebilirsiniz. Örneğin:\n\n```go\ntype Fooer interface {\n Foo()\n ImplementsFooer()\n}\n```\n\nBir tür daha sonra bir Fooer olmak için ImplementsFooer yöntemini uygulamalı, gerçeği açıkça belgelendirmeli ve [go doc](https://golang.org/cmd/go/#hdr-Show\\_documentation\\_for\\_package\\_or\\_symbol)'un çıktısında duyurmalıdır.\n\n```go\ntype Bar struct{}\nfunc (b Bar) ImplementsFooer() {}\nfunc (b Bar) Foo() {}\n```\n\nÇoğu kod, arayüz fikrinin faydasını sınırladıkları için bu tür kısıtlamaları kullanmaz. Yine de bazen benzer arayüzler arasındaki belirsizlikleri çözmek için gereklidirler.\n\n### ➡️ T türü neden Equal arayüzünü karşılamıyor?\n\nBu basit arayüzü, kendisini başka bir değerle karşılaştırabilen bir nesneyi temsil edecek şekilde düşünün:\n\n```go\ntype Equaler interface {\n Equal(Equaler) bool\n}\n```\n\nve bu tür, T:\n\n```go\ntype T int\nfunc (t T) Equal(u T) bool { return t == u } // Equaler'ı karşılamıyor\n```\n\nBazı polimorfik tip sistemlerde benzer durumdan farklı olarak, T, Equaler'ı uygulamaz. T.Equal'ın bağımsız değişken türü T'dir, tam anlamıyla gerekli olan Equaler türü değildir.\n\nGo'da tip sistemi Equal argümanını desteklemez; Bu, Equaler'ı uygulayan T2 türünde gösterildiği gibi programcının sorumluluğundadır:\n\n```go\ntype T2 int\nfunc (t T2) Equal(u Equaler) bool { return t == u.(T2) } //Equalerı karşılar\n```\n\nBu bile diğer tür sistemler gibi değildir, çünkü Go'da Equaler'ı karşılayan herhangi bir tür argüman olarak T2.Equal'a aktarılabilir ve çalışma zamanında argümanın T2 türünde olup olmadığını kontrol etmeliyiz. Bazı diller bu garantiyi derleme zamanında verir. İlgili bir örnek diğer tarafa gider:\n\n```go\ntype Opener interface {\n Open() Reader\n}\n\nfunc (t T3) Open() *os.File\n```\n\nGo'da T3, başka bir dilde olsa da Opener'ı karşılamıyor. Go'nun tip sisteminin bu gibi durumlarda programcı için daha az şey yaptığı doğru olsa da, alt tiplemenin olmaması arayüz memnuniyeti ile ilgili kuralları belirtmeyi çok kolaylaştırır: fonksiyonun adları ve imzaları tam olarak arayüzünkiler mi?\n\nGo kuralının verimli bir şekilde uygulanması da kolaydır. Bu avantajların, otomatik tip promosyon eksikliğini telafi ettiğini düşünüyoruz. Bir gün, bir tür polimorfik yazım benimsemesi durumunda, bu örneklerin fikrini ifade etmenin ve ayrıca bunların statik olarak kontrol edilmesini sağlamanın bir yolu olacağını umuyoruz.\n\n### ➡️ Bir \\[]T'yi bir \\[]interface'e dönüştürebilir miyim?\n\nDirekt olarak değil. İki tür bellekte aynı temsile sahip olmadığından dil belirtimine göre buna izin verilmez. Öğeleri tek tek hedef dilime kopyalamak gerekir. Bu örnek, bir int dilimini bir interface{} dilimine dönüştürür:\n\n```go\nt := []int{1, 2, 3, 4}\ns := make([]interface{}, len(t))\nfor i, v := range t {\n s[i] = v\n}\n```\n\n### ➡️ T1 ve T2 aynı temel türe sahipse \\[] T1'i \\[] T2'ye dönüştürebilir miyim?\n\nBu kod örneğinin bu son satırı derlenmiyor.\n\n```go\ntype T1 int\ntype T2 int\nvar t1 T1\nvar x = T2(t1) // Tamam\nvar st1 []T1\nvar sx = ([]T2)(st1) // tamam değil\n```\n\nGo'da türler, her adlandırılmış türün (muhtemelen boş) bir yöntem kümesine sahip olması nedeniyle metodlara yakından bağlıdır. Genel kural, dönüştürülen türün adını değiştirebilmeniz (ve dolayısıyla muhtemelen yöntem kümesini değiştirebilmeniz), ancak bileşik türdeki öğelerin adını (ve yöntem kümesini) değiştirememenizdir. Go, tür dönüşümleri konusunda açık olmanızı gerektirir.\n\n### ➡️ Nil hata değerim neden nil'e eşit değil?\n\nKapakların altında, arayüzler iki öğe olarak uygulanır; bir T türü ve bir V değeri V, int, struct veya işaretçi gibi somut bir değerdir, hiçbir zaman arabirim değildir ve T türüne sahiptir. Örneğin, int değeri 3 bir arabirimde, ortaya çıkan arabirim değeri şematik olarak (T = int, V = 3) olur. V değeri, aynı zamanda arayüzün dinamik değeri olarak da bilinir, çünkü belirli bir arayüz değişkeni, programın yürütülmesi sırasında farklı V değerlerini (ve karşılık gelen T tiplerini) tutabilir. Bir arabirim değeri, yalnızca V ve T'nin her ikisi de ayarlanmamışsa sıfırdır (T = nil, V ayarlanmamış). Özellikle, bir sıfır arabirim her zaman bir sıfır türünü tutacaktır. Bir arabirim değerinin içinde _int türünde bir sıfır gösterici saklarsak, iç tür, işaretçinin değerine bakılmaksızın_ int olacaktır: (T = \\* int, V = nil). Bu nedenle, bu tür bir arayüz değeri, içindeki işaretçi değeri V sıfır olduğunda bile sıfır olmayacaktır. Bu durum kafa karıştırıcı olabilir ve bir sıfır değeri gibi bir arayüz değerinin içinde saklandığında ortaya çıkar. hata dönüşü:\n\n```go\nfunc returnsError() error {\n\tvar p *MyError = nil\n\tif bad() {\n\t\tp = ErrBad\n\t}\n\treturn p // herzaman nil olmayan hata döndürür\n}\n```\n\nHer şey yolunda giderse, işlev bir nil p döndürür, dolayısıyla dönüş değeri bir hata arabirim değeridir (T = \\* MyError, V = nil). Bu, arayanın döndürdüğü hatayı nil ile karşılaştırması durumunda, kötü bir şey olmasa bile her zaman bir hata varmış gibi görüneceği anlamına gelir. Çağırana uygun bir sıfır hatası döndürmek için, işlevin açık bir nil döndürmesi gerekir:\n\n```go\nfunc returnsError() error {\n\tif bad() {\n\t\treturn ErrBad\n\t}\n\treturn nil\n}\n```\n\nHataları döndüren fonksiyonların, hatanın doğru şekilde oluşturulmasını garantilemeye yardımcı olmak için _ `MyError` gibi somut bir tür yerine (yukarıda yaptığımız gibi) imzalarında her zaman hata türünü kullanmaları iyi bir fikirdir. Örnek olarak,_ [_os.Open_](https://golang.org/pkg/os/#Open)_, sıfır değilse bile, her zaman somut_ [\\*os.PathError](https://golang.org/pkg/os/#PathError) türünde olsa bile bir hata döndürür. Burada açıklananlara benzer durumlar, arayüzler her kullanıldığında ortaya çıkabilir. Arayüzde herhangi bir somut değer saklandıysa arayüzün `nil` olmayacağını unutmayın. Daha fazla bilgi için [Yansıma Yasaları](https://golang.org/doc/articles/laws\\_of\\_reflection.html)'na bakın.\n\n### ➡️ C'de olduğu gibi neden untagged unions yok?\n\nUntagged unions, Go'nun bellek güvenliği garantilerini ihlal eder.\n\n### ➡️ Go'da neden varyant türleri yok?\n\nCebirsel türler olarak da bilinen değişken türleri, bir değerin diğer türlerden birini, ancak yalnızca bu türleri alabileceğini belirtmenin bir yolunu sağlar. Sistem programlamasında yaygın bir örnek, bir hatanın, örneğin bir ağ hatası, bir güvenlik hatası veya bir uygulama hatası olduğunu belirtir ve arayanın, hatanın türünü inceleyerek sorunun kaynağını ayırt etmesine izin verir.\n\nBaşka bir örnek, her bir düğümün farklı bir türde olabileceği bir sözdizimi ağacıdır: bildirim, ifade, atama vb. Go'ya varyant türleri eklemeyi düşündük, ancak tartışmadan sonra, arayüzlerle kafa karıştırıcı şekillerde çakıştıkları için bunları dışarıda bırakmaya karar verdik.\n\nBir varyant türünün öğelerinin kendileri arayüz olsaydı ne olurdu? Ayrıca, hangi varyant türlerinin adreslendiğinden bazıları zaten dil tarafından kapsanmaktadır. Hata örneğini, hatayı tutmak için bir arayüz değeri ve durumları ayırt etmek için bir tür anahtarı kullanarak ifade etmek kolaydır. Sözdizimi ağacı örneği, o kadar zarif olmasa da yapılabilir.\n\n### ➡️ Go neden ortak değişken sonuç türlerine sahip değil?\n\nKovaryant (ortak değişken) sonuç türleri, benzer bir arayüzün\n\n```go\ntype Copyable interface {\n\tCopy() interface{}\n}\n```\n\nyöntemle karşılanmalı\n\n```go\nfunc (v Value) Copy() Value\n```\n\nÇünkü Değer, boş arayüzü uygular. Go metodunda türlerin tam olarak eşleşmesi gerekir, bu nedenle Value Copyable'ı uygulamaz. Go, bir türün ne yaptığı kavramını - yöntemlerini - türün uygulamasından ayırır. İki yöntem farklı türler döndürürse, aynı şeyi yapmazlar. Kovaryant sonuç türleri isteyen programcılar genellikle arayüzler aracılığıyla bir tür hiyerarşisini ifade etmeye çalışırlar. Go'da arayüz ve uygulama arasında temiz bir ayrım olması daha doğaldır.\n\n## 🔘 Değerler\n\n### ➡️ Go neden örtük sayısal dönüşümler sağlamaz?\n\nC'deki sayısal türler arasında otomatik dönüşümün rahatlığı, neden olduğu kafa karışıklığından daha ağır basmaktadır. Bir ifade ne zaman işaretsizdir? Değer ne kadar büyük? Taşıyor mu? Sonuç, üzerinde yürütüldüğü makineden bağımsız olarak taşınabilir mi? Ayrıca derleyiciyi karmaşıklaştırır; \"Olağan aritmetik dönüşümlerin\" uygulanması kolay değildir ve mimariler arasında tutarsızdır. \n\nTaşınabilirlik nedenlerinden dolayı, koddaki bazı açık dönüşümler pahasına işleri net ve anlaşılır hale getirmeye karar verdik. Go'daki sabitlerin tanımı - işaretsiz ve boyut ek açıklamaları içermeyen keyfi kesinlik değerleri - yine de sorunları önemli ölçüde iyileştirir. Bununla ilgili bir ayrıntı, C'den farklı olarak int ve int64'ün, int 64 bitlik bir tür olsa bile farklı türler olmasıdır. İnt türü geneldir; Bir tamsayının kaç bit tuttuğunu önemsiyorsanız, Go sizi açık sözlü olmaya teşvik eder.\n\n### ➡️ Sabitler Go'da nasıl çalışır?\n\nGo, farklı sayısal türlerdeki değişkenler arasında dönüşüm konusunda katı olmasına rağmen, dildeki sabitler çok daha esnektir. 23, 3.14159 ve math.Pi gibi değişmez sabitler, keyfi bir hassasiyetle ve taşma veya yetersizlik olmadan bir tür ideal sayı alanı kaplar. Örneğin, math.Pi'nin değeri kaynak kodda 63 basamak olarak belirtilir ve değeri içeren sabit ifadeler, bir float64'ün tutabileceğinin ötesinde hassasiyeti korur. Yalnızca sabit veya sabit ifade bir değişkene (programdaki bir bellek konumuna) atandığında, normal kayan nokta özelliklerine ve hassasiyetine sahip bir \"bilgisayar\" numarası olur.\n\nAyrıca, bunlar tiplenmiş değerler değil, sadece sayılar oldukları için, Go'daki sabitler değişkenlere göre daha özgürce kullanılabilir, böylece katı dönüştürme kuralları etrafındaki bazı gariplikleri yumuşatır.Aşağıdaki gibi ifadeler yazılabilir:\n\n```go\nsqrt2 := math.Sqrt(2)\n```\n\nderleyiciden şikayet etmeden ideal sayı 2, math.Sqrt çağrısı için güvenli ve doğru bir şekilde float64'e dönüştürülebilir.\n\n[Sabitler](https://blog.golang.org/constants) başlıklı bir blog yazısı bu konuyu daha ayrıntılı olarak araştırıyor. Ve bu dökümandan sabitleri inceleyebilirsiniz.\n\n{% content-ref url=\"sabitler.md\" %}\n[sabitler.md](sabitler.md)\n{% endcontent-ref %}\n\n### ➡️ Map neden built-in (yerleşik)?\n\nStringler ile aynı nedeni şudur: o kadar güçlü ve önemli bir veri yapısıdır ki sözdizimsel destek ile mükemmel bir uygulama sağlamak, programlamayı daha keyifli hale getirir. Go'nun map uygulamasının, kullanımların büyük çoğunluğuna hizmet edecek kadar güçlü olduğuna inanıyoruz. Belirli bir uygulama özel bir uygulamadan yararlanabiliyorsa, bir tane yazmak mümkündür, ancak sözdizimsel olarak o kadar kullanışlı olmayacaktır; bu makul bir değiş tokuş gibi görünüyor.\n\n### ➡️ Map neden dilimlere (slices) anahtar (key) olarak izin vermiyor?\n\nHarita arama, dilimlerin uygulanmadığı bir eşitlik operatörü gerektirir. Eşitliği uygulamazlar çünkü eşitlik bu tür türlerde iyi tanımlanmamıştır; sığ ve derin karşılaştırma, işaretçi ile değer karşılaştırması, özyinelemeli türlerle nasıl başa çıkılacağı gibi birçok husus vardır. Bu konuyu tekrar gözden geçirebiliriz - ve dilimler için eşitliği uygulamak mevcut programları geçersiz kılmaz - ancak dilimlerin eşitliğinin ne anlama geldiği konusunda net bir fikir olmadan, şimdilik bunu dışarıda bırakmak daha kolaydı.\n\nGo 1'de, önceki sürümlerden farklı olarak, yapılar ve diziler için eşitlik tanımlanmıştır, bu nedenle bu tür türler eşleme anahtarları olarak kullanılabilir. Yine de dilimler hala bir eşitlik tanımına sahip değil.\n\n### ➡️ Diziler değer iken neden map'ler, dilimler ve kanallar referanslarıdır?\n\nBu konuyla ilgili çok fazla tarih var. Eskiden, map'ler ve kanallar sözdizimsel olarak işaretçilerdi ve işaretçi olmayan bir örneği bildirmek veya kullanmak imkansızdı. Ayrıca dizilerin nasıl çalışması gerektiğiyle uğraştık. Sonunda, işaretçilerin ve değerlerin katı bir şekilde ayrılmasının, dili kullanmayı zorlaştırdığına karar verdik. Bu türlerin ilişkili, paylaşılan veri yapılarına referans görevi görecek şekilde değiştirilmesi bu sorunları çözdü. Bu değişiklik, dile üzücü bir karmaşıklık kattı ancak kullanılabilirlik üzerinde büyük bir etkiye sahipti: Go, tanıtıldığında daha üretken ve rahat bir dil haline geldi.\n\n## 🔘 Kod Yazma\n\n### ➡️ Kütüphaneler nasıl belgelenir?\n\nGo'da yazılmış, kaynak koddan paket belgelerini çıkaran ve bunu bildirimlere, dosyalara vb. Bağlantılar içeren bir web sayfası olarak hizmet veren bir program var. [golang.org/pkg/](https://golang.org/pkg/) adresinde bir örnek çalışıyor. Aslında, `godoc` sitenin tamamını [golang.org/](https://golang.org/) adresinde uygulamaktadır.\n\nBir godoc örneği, görüntülediği programlarda sembollerin zengin, etkileşimli statik analizlerini sağlamak üzere yapılandırılabilir; detaylar [burada](https://golang.org/lib/godoc/analysis/help.html) listelenmiştir.\n\nKomut satırından belgelere erişim için, [go](https://golang.org/pkg/cmd/go/) aracı aynı bilgilere bir metinsel arayüzü sağlayan bir [doc](https://golang.org/pkg/cmd/go/#hdr-Show\\_documentation\\_for\\_package\\_or\\_symbol) alt komutunu vardır.\n\n### ➡️ Go programlama stili kılavuzu var mı?\n\nKesinlikle tanınabilir bir \"Go stili\" olmasına rağmen açık bir stil kılavuzu yoktur.\n\nGo, adlandırma, düzen ve dosya organizasyonu ile ilgili kararlara rehberlik edecek kurallar oluşturmuştur. [Effective Go](https://golang.org/doc/effective\\_go.html) belgesi bu konularla ilgili bazı tavsiyeler içermektedir. Daha doğrusu, gofmt programı, amacı düzen kurallarını uygulamak olan güzel bir yazıcıdır; yorumlamaya izin veren olağan yapılması ve yapılmaması gerekenler özetinin yerini alır. Depodaki tüm Go kodu ve açık kaynak dünyasının büyük çoğunluğu gofmt aracılığıyla çalıştırılmıştır.\n\n[Go Code Review Comments](https://golang.org/s/comments) başlıklı belge, programcılar tarafından genellikle gözden kaçırılan Go deyiminin ayrıntılarıyla ilgili çok kısa denemelerden oluşan bir derlemedir. Go projeleri için kod incelemeleri yapan kişiler için kullanışlı bir referanstır.\n\n### ➡️ Yamaları Go kütüphanelerine nasıl gönderirim?\n\nKütüphane kaynakları, arşivin `src` dizinindedir. Önemli bir değişiklik yapmak istiyorsanız, lütfen başlamadan önce posta listesinde tartışın.\n\nNasıl ilerleyeceğiniz hakkında daha fazla bilgi için [Go projesine katkıda bulunmak](https://golang.org/doc/contribute.html) belgesine bakın.\n\n### ➡️ \"go get\" bir depoyu klonlarken neden HTTPS kullanıyor?\n\nŞirketler genellikle giden trafiğe yalnızca standart TCP bağlantı noktaları 80 (HTTP) ve 443 (HTTPS) üzerinden izin vererek, TCP bağlantı noktası 9418 (git) ve TCP bağlantı noktası 22 (SSH) dahil olmak üzere diğer bağlantı noktalarında giden trafiği engeller. HTTP yerine HTTPS kullanırken, git varsayılan olarak sertifika doğrulamasını zorlayarak ortadaki adam, gizli dinleme ve kurcalama saldırılarına karşı koruma sağlar. Bu nedenle `go get`komutu, güvenlik için HTTPS kullanır. Git, HTTPS üzerinden kimlik doğrulaması yapacak veya HTTPS yerine SSH kullanacak şekilde yapılandırılabilir. HTTPS üzerinden kimlik doğrulaması yapmak için `$ HOME / .netrc` dosyasına git'in başvurduğu bir satır ekleyebilirsiniz:\n\n```\nmachine github.com login USERNAME password APIKEY\n```\n\nGitHub hesapları için parola [kişisel bir erişim belirteci](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/) olabilir.\n\nGit, belirli bir önekle eşleşen URL'ler için HTTPS yerine SSH kullanacak şekilde de yapılandırılabilir. Örneğin, tüm GitHub erişiminde SSH kullanmak için şu satırları `~/.gitconfig` dosyanıza ekleyin:\n\n```\n[url \"ssh://git@github.com/\"]\n\tinsteadOf = https://github.com/\n```\n\n### ➡️ \"Go get\" kullanarak paket sürümlerini nasıl yönetmeliyim?\n\nProjenin başlangıcından bu yana, Go'nun açık bir paket sürümleri kavramı yoktu, ancak bu değişiyor. Versiyon oluşturma, özellikle büyük kod tabanlarında önemli bir karmaşıklık kaynağıdır ve tüm Go kullanıcılarına sağlanmaya uygun olacak kadar geniş bir çeşitlilikteki durumlarda ölçekte iyi çalışan bir yaklaşım geliştirmek biraz zaman almıştır. Go 1.11 sürümü, Go modülleri biçiminde go komutuna paket sürüm oluşturma için yeni, deneysel destek ekler. Daha fazla bilgi için [Go 1.11 sürüm notlarına](https://golang.org/doc/go1.11#modules) ve [go komutu belgeleri](https://golang.org/cmd/go#hdr-Modules\\_\\_module\\_versions\\_\\_and\\_more)ne bakın.\n\nGerçek paket yönetimi teknolojisinden bağımsız olarak, \"go get\" ve daha büyük Go araç zinciri, farklı içe aktarma yollarına sahip paketlerin izolasyonunu sağlar. Örneğin, standart kitaplığın `html/template` ve `text/template`, her ikisi de \"package template\" olsa bile bir arada bulunur.\n\nBu gözlem, paket yazarları ve paket kullanıcıları için bazı tavsiyelere yol açar. Kamusal kullanıma yönelik paketler, geriye dönük uyumluluğu korumaya çalışmalıdır. gelişmek. [Go 1 uyumluluk yönergeleri](https://golang.org/doc/go1compat.html) burada iyi bir referanstır: dışa aktarılan adları kaldırmayın, etiketli bileşik değişmez değerleri teşvik edin, vb. Farklı işlevler gerekiyorsa, eskisini değiştirmek yerine yeni bir ad ekleyin. Tam bir ara verilmesi gerekiyorsa, yeni bir içe aktarma yolu ile yeni bir paket oluşturun. Harici olarak sağlanan bir paket kullanıyorsanız ve beklenmedik şekillerde değişebileceğinden endişeleniyorsanız, ancak henüz Go modüllerini kullanmıyorsanız, en basit çözüm onu ​​yerel deponuza kopyalamaktır. Bu, Google'ın dahili olarak kullandığı yaklaşımdır ve \"vendoring\" adı verilen bir teknik aracılığıyla go komutuyla desteklenir. Bu, bağımlılığın bir kopyasını, onu yerel bir kopya olarak tanımlayan yeni bir içe aktarma yolu altında depolamayı içerir. Ayrıntılar için [tasarım belgesi](https://golang.org/s/go15vendor)ne bakın.\n\n## 🔘 İşaretçiler ve Tahsis\n\n### ➡️ Fonksiyon parametreleri ne zaman değere göre aktarılır?\n\nC ailesindeki tüm dillerde olduğu gibi, Go'daki her şey değer bazında aktarılır. Diğer bir deyişle, bir işlev, değeri parametreye atayan bir atama ifadesi varmış gibi, her zaman iletilmekte olan şeyin bir kopyasını alır. Örneğin, bir fonksiyona bir int değerinin iletilmesi, int'in bir kopyasını oluşturur ve bir işaretçi değerinin iletilmesi, işaretçinin bir kopyasını oluşturur, ancak gösterdiği verilerin bir kopyasını oluşturmaz. (Bunun yöntem alıcılarını nasıl etkilediğiyle ilgili bir tartışma için sonraki bölüme bakın.) Map ve dilim (slice) değerleri, işaretçiler gibi davranır: bunlar, temel alınan map'e veya dilim verilerine işaretçiler içeren tanımlayıcılardır.\n\nBir map'in veya dilim değerinin kopyalanması, işaret ettiği verileri kopyalamaz. Bir arayüz değerinin kopyalanması, arayüz değerinde depolanan şeyin bir kopyasını oluşturur. Arayüz değeri bir yapı (struct) içeriyorsa, arayüz değerinin kopyalanması yapının bir kopyasını oluşturur. Arabirim değeri bir işaretçi tutuyorsa, arayüz değerinin kopyalanması işaretçinin bir kopyasını oluşturur, ancak yine işaret ettiği veriyi oluşturmaz. Bu tartışmanın, işlemlerin anlambilim. Gerçek uygulamalar, optimizasyonlar anlambilimini değiştirmediği sürece kopyalamayı önlemek için optimizasyonları uygulayabilir.\n\n### ➡️ Bir arayüze işaretçi ne zaman kullanmalıyım?\n\nNeredeyse hiç. Arayüz değerlerine yönelik işaretçiler yalnızca, gecikmeli değerlendirme için bir arayüz değerinin türünü gizlemeyi içeren nadir, zor durumlarda ortaya çıkar.\n\nBir arayüz bekleyen bir işleve bir arayüz değerine bir işaretçi iletmek yaygın bir hatadır. Derleyici bu hatadan şikayet eder, ancak durum yine de kafa karıştırıcı olabilir, çünkü bazen bir [arayüzü karşılamak için bir işaretçi](https://golang.org/doc/faq#different\\_method\\_sets) gerekir. Buradaki fikir, somut bir tipe bir işaretçi bir arayüzü karşılayabilmesine rağmen, bir istisna dışında, bir arayüze yönelik bir işaretçinin bir arayüze asla karşılamayacağıdır.\n\nDeğişken tanımlamayı düşünün,\n\n```go\nvar w io.Writer\n```\n\nfmt.Fprintf yazdırma fonksiyonu, ilk argüman olarak io.Writer'ı karşılayan bir değer alır - bu, kurallı Write metodunu uygulayan bir şeydir. Böylece yazabiliriz\n\nAncak w'nin adresini geçersek, program derlenmeyecektir.\n\n```go\nfmt.Fprintf(&w, \"hello, world\\n\") //Derleme-zamanı hatası.\n```\n\nBunun tek istisnası, herhangi bir değerin, hatta bir arayüze işaretçi bile, boş arayüze türündeki bir değişkene (interface{}) atanabilmesidir. Öyle olsa bile, değerin bir arayüze işaretçi olması neredeyse kesinlikle bir hatadır; sonuç kafa karıştırıcı olabilir.\n\n### ➡️ Metodları (struct fonksiyonlar) değerler veya işaretçiler üzerinde tanımlamalı mıyım?\n\n```go\nfunc (s *MyStruct) pointerMethod() { } // işaretçi metod\nfunc (s MyStruct) valueMethod() { } // değer metod\n```\n\nİşaretçilere alışkın olmayan programcılar için bu iki örnek arasındaki ayrım kafa karıştırıcı olabilir, ancak durum aslında çok basittir. Bir tür üzerinde bir metodu tanımlarken, alıcı (yukarıdaki örneklerde `s`) tam olarak metodun bir argümanıymış gibi davranır. Alıcının bir değer olarak mı yoksa bir işaretçi olarak mı tanımlanacağı aynı sorudur, o halde, bir fonksiyon bağımsız değişkeninin bir değer mi yoksa bir işaretçi mi olması gerektiği sorusudur.\n\nDikkat edilmesi gereken birkaç nokta var. İlk ve en önemlisi, metodun alıcıyı değiştirmesi gerekiyor mu? Eğer öyleyse, alıcının bir işaretçi olması gerekir. (Dilimler ve map'ler referans görevi görür, bu nedenle hikayeleri biraz daha inceliklidir, ancak örneğin bir yöntemdeki bir dilimin uzunluğunu değiştirmek için alıcının yine de bir işaretçi olması gerekir.)\n\nYukarıdaki örneklerde, `pointerMethod` alanlarını değiştirirse `s`, arayan bu değişiklikleri görecektir, ancak `valueMethod`, arayanın argümanının bir kopyasıyla çağrılır (bu, bir değeri iletmenin tanımıdır), bu nedenle yaptığı değişiklikler görünmez olacaktır arayana.\n\nBu arada, Java metodlarında alıcılar her zaman işaretçilerdir, ancak işaretçi doğaları bir şekilde gizlenmiştir (ve dile değer alıcıları eklemek için bir öneri vardır). Sıradışı olan, Go'daki değer alıcılarıdır. İkincisi, verimliliğin dikkate alınmasıdır. Alıcı büyükse, örneğin büyük bir yapıya sahipse, bir işaretçi alıcı kullanmak çok daha ucuz olacaktır.\n\nSırada tutarlılık var. Türün bazı metodlarının işaretçi alıcıları olması gerekiyorsa, geri kalanı da olmalıdır, bu nedenle metod kümesi türün nasıl kullanıldığına bakılmaksızın tutarlıdır. Ayrıntılar için [metod kümeleri](https://golang.org/doc/faq#different\\_method\\_sets) bölümüne bakın.\n\nTemel türler, dilimler ve küçük yapılar gibi türler için, bir değer alıcısı çok ucuzdur, bu nedenle metodun anlambilimi bir işaretçi gerektirmedikçe, bir değer alıcısı verimli ve nettir.\n\n### ➡️ Make ve New arasındaki fark nedir?\n\n**Kısaca:** new, bellek ayırır. Make ise dilim, map ve kanal türlerini başlatır.\n\nDaha fazla ayrıntı için [Effective Go'nun ilgili bölümü](https://golang.org/doc/effective\\_go.html#allocation\\_new)ne bakın.\n\n### ➡️ Bir int türün 64bitlik makinedeki büyüklüğü nedir?\n\nInt ve uint boyutları uygulamaya özgüdür ancak belirli bir platformda birbirleriyle aynıdır. Taşınabilirlik için, belirli bir değer boyutuna dayanan kod, int64 gibi açıkça boyutlandırılmış bir tür kullanmalıdır. 32-bit makinelerde derleyiciler varsayılan olarak 32-bit tamsayılar kullanırken, 64-bit makinelerde tamsayılar 64 bit'e sahiptir. (Tarihsel olarak bu her zaman doğru değildi.)\n\nÖte yandan, kayan nokta skalerleri ve karmaşık türler her zaman boyutlandırılır (kayan nokta veya karmaşık temel türler yoktur), çünkü programcılar kayan noktalı (burada float'dan bahsediyor) sayıları kullanırken hassasiyetin farkında olmalıdır. Bir (türlenmemiş - untyped) kayan nokta sabiti için kullanılan varsayılan tür float64'tür. Böylece `foo: = 3.0, float64` türünde bir değişken `foo` bildirir. Bir (türlenmemiş) sabit tarafından başlatılan `float32` değişkeni için değişken türü, değişken bildiriminde açıkça belirtilmelidir:\n\n```go\nvar foo float32 = 3.0\n```\n\nAlternatif olarak, sabite `foo: = float32 (3.0)` 'da olduğu gibi dönüşümlü bir tür verilmelidir.\n\n### ➡️ Bir değişkenin yığın üzerinde mi yoksa yığın üzerinde tahsis edildiğini nasıl anlarım?\n\nDoğruluk açısından, bilmenize gerek yok. Go'daki her değişken, kendisine referans olduğu sürece var olur. Uygulama tarafından seçilen depolama konumu, dilin anlambilimiyle ilgisizdir.\n\nDepolama konumu, verimli programlar yazma üzerinde bir etkiye sahiptir. Mümkün olduğunda, Go derleyicileri, o işlevin yığın çerçevesindeki bir işleve yerel olan değişkenleri tahsis eder. Ancak, derleyici işlev döndükten sonra değişkene başvurulmadığını kanıtlayamazsa, derleyicinin işaretçi hatalarının sarkmasını önlemek için değişkeni çöpte toplanan yığın üzerinde tahsis etmesi gerekir.\n\nAyrıca, yerel bir değişken çok büyükse, onu yığın yerine yığın üzerinde depolamak daha mantıklı olabilir. Mevcut derleyicilerde, bir değişkenin adresi alınmışsa, bu değişken öbek üzerinde tahsisat için bir adaydır. Bununla birlikte, temel bir kaçış analizi, bu tür değişkenlerin işlevin geri dönüşünü geçemez ve tanımsız yığındır.\n\n### ➡️ Go işlemim neden bu kadar çok sanal bellek kullanıyor?\n\nGo bellek ayırıcısı, ayırmalar için bir alan olarak büyük bir sanal bellek bölgesini ayırır. Bu sanal bellek, belirli Go işlemi için yereldir; rezervasyon, diğer bellek işlemlerini mahrum etmez.\n\nBir Go işlemine ayrılan gerçek bellek miktarını bulmak için Unix `top` komutunu kullanın ve RES (Linux) veya RSIZE (macOS) sütunlarına bakın.\n\n## 🔘 Eşzamanlılık\n\n### ➡️ Hangi işlemler atomiktir? Mutexler ne olacak?\n\nGo'daki işlemlerin atomikliğine ilişkin bir açıklama [Go Bellek Modeli](https://golang.org/ref/mem) belgesinde bulunabilir.\n\nDüşük seviyeli senkronizasyon ve atomik ilkeller, [sync](https://golang.org/pkg/sync) ve [sync/atomic](https://golang.org/pkg/sync/atomic) paketlerinde mevcuttur.\n\nBu paketler, referans sayılarını artırmak veya küçük ölçekli karşılıklı dışlamayı garanti etmek gibi basit görevler için iyidir. Eşzamanlı sunucular arasında koordinasyon gibi daha yüksek seviyeli işlemler için, daha yüksek seviyeli teknikler daha güzel programlara yol açabilir ve Go, bu yaklaşımı kendi düzenleri ve kanalları aracılığıyla destekler. Örneğin, programınızı belirli bir veri parçasından her seferinde yalnızca bir gorutin sorumlu olacak şekilde yapılandırabilirsiniz. Bu yaklaşım, orijinal [Go atasözü](https://www.youtube.com/watch?v=PAAkCSZUG1c) ile özetlenmiştir.\n\nHafızayı paylaşarak iletişim kurmayın. Bunun yerine, iletişim kurarak hafızayı paylaşın. Bu kavramın ayrıntılı bir tartışması için, [İletişimi Kurarak Belleği Paylaşma](https://golang.org/doc/codewalk/sharemem/) [kod yürüyüşüne ve ilgili](https://blog.golang.org/2010/07/share-memory-by-communicating.html) makalesine bakın. Büyük eşzamanlı programlar muhtemelen bu iki araç setinden ödünç alır.\n\n### ➡️ Programım neden daha fazla CPU ile daha hızlı çalışmıyor?\n\nBir programın daha fazla CPU ile daha hızlı çalışıp çalışmadığı, çözmekte olduğu soruna bağlıdır. Go dili, gorutinler ve kanallar gibi eşzamanlılık ilkelleri sağlar, ancak eşzamanlılık yalnızca temeldeki sorun doğası gereği paralel olduğunda paralellik sağlar.\n\nDoğası gereği sıralı olan sorunlar, daha fazla CPU eklenerek hızlandırılamazken, paralel olarak yürütülebilen parçalara ayrılabilen sorunlar bazen dramatik bir şekilde hızlandırılabilir. Bazen daha fazla CPU eklemek bir programı yavaşlatabilir. Pratik anlamda, eşitleme veya iletişim için yararlı hesaplamalar yapmaktan daha fazla zaman harcayan programlar, birden çok işletim sistemi iş parçacığı kullanırken performans düşüşü yaşayabilir. Bunun nedeni, iş parçacıkları arasında veri geçişinin, önemli bir maliyeti olan bağlamları değiştirmeyi gerektirmesidir ve bu maliyet daha fazla CPU ile artabilir. Örneğin, Go spesifikasyonundaki ana elek örneğinin pek çok gorutini başlatmasına rağmen önemli bir paralelliği yoktur; sayısını artırmak thread'ler (CPU'lar) hızlandırmaktan çok yavaşlatır.\n\nBu konu hakkında daha fazla ayrıntı için [Concurrency is not Parallelism](https://blog.golang.org/2013/01/concurrency-is-not-parallelism.html) başlıklı konuşmaya bakın.\n\n### ➡️ CPU sayısını nasıl kontrol edebilirim?\n\nYürütülen programlı dizinler için aynı anda kullanılabilen CPU sayısı, varsayılan değeri mevcut CPU çekirdeği sayısı olan `GOMAXPROCS` kabuk ortam değişkeni tarafından kontrol edilir. Paralel yürütme potansiyeli olan programlar bu nedenle bunu varsayılan olarak çoklu CPU'lu bir makinede gerçekleştirmelidir. Kullanılacak paralel CPU sayısını değiştirmek için ortam değişkenini ayarlayın veya çalışma zamanı desteğini farklı sayıda iş parçacığı kullanacak şekilde yapılandırmak için çalışma zamanı paketinin benzer adlandırılmış işlevini kullanın. 1 olarak ayarlamak, bağımsız gorutinleri sırayla yürütmeye zorlayarak gerçek paralellik olasılığını ortadan kaldırır. Çalışma zamanı, birden çok bekleyen G / Ç isteğine hizmet vermek için `GOMAXPROCS` değerinden daha fazla iş parçacığı ayırabilir. \n\n`GOMAXPROCS` yalnızca aynı anda kaç tane gorutinin çalıştırabileceğini etkiler; sistem çağrılarında keyfi olarak daha fazlası engellenebilir. Go'nun gorutin programlayıcısı, zamanla gelişmesine rağmen olması gerektiği kadar iyi değildir. Gelecekte daha iyi olabilir OS iş parçacığı kullanımını optimize eder. Şimdilik, performans sorunları varsa, `GOMAXPROCS`'u uygulama bazında ayarlamak yardımcı olabilir.\n\n### ➡️ Gorutin olarak çalışan kapanışlarda ne olur?\n\nEşzamanlı kapanışlar kullanıldığında bazı karışıklıklar ortaya çıkabilir. Aşağıdaki programı düşünün:\n\n```go\nfunc main() {\n done := make(chan bool)\n\n values := []string{\"a\", \"b\", \"c\"}\n for _, v := range values {\n go func() {\n fmt.Println(v)\n done <- true\n }()\n }\n\n // çıkmadan önce tüm goroutinlerin tamamlanmasını bekle\n for _ = range values {\n <-done\n }\n}\n```\n\nBir kimse yanlışlıkla çıktı olarak `a, b, c`'yi görmeyi bekleyebilir. Bunun yerine muhtemelen göreceğiniz şey `c, c, c`'dir. Bunun nedeni, döngünün her yinelemesinin `v` değişkeninin aynı örneğini kullanmasıdır, bu nedenle her kapanış bu tek değişkeni paylaşır. Kapatma çalıştığında, `fmt.Println` yürütüldüğünde `v` değerini yazdırır, ancak gorutin başlatıldıktan sonra `v` değiştirilmiş olabilir. Bunu ve diğer sorunları ortaya çıkmadan önce tespit etmeye yardımcı olmak için [go vet](https://golang.org/cmd/go/#hdr-Run\\_go\\_tool\\_vet\\_on\\_packages) komutunu kullanın.\n\n`v`'nin geçerli değerini, başlatıldığında her kapanışa bağlamak için, her yinelemede yeni bir değişken oluşturmak için iç döngü değiştirilmelidir. Bir yol, değişkeni kapanışa bir argüman olarak iletmektir:\n\n```go\n for _, v := range values {\n go func(u string) {\n fmt.Println(u)\n done <- true\n }(v)\n }\n```\n\nBu örnekte, `v`'nin değeri anonim işleve argüman olarak aktarılır. Bu değere daha sonra fonksiyonun içinde `u` değişkeni olarak erişilebilir. Daha da kolay olanı, tuhaf görünebilecek ancak Go'da iyi çalışan bir tanımlama stili kullanarak yeni bir değişken oluşturmaktır:\n\n```go\n for _, v := range values {\n v := v // create a new 'v'.\n go func() {\n fmt.Println(v)\n done <- true\n }()\n }\n```\n\nHer yineleme için yeni bir değişken tanımlamayan dilin bu davranışı, geçmişe bakıldığında bir hata olabilir. Daha sonraki bir sürümde ele alınabilir, ancak uyumluluk için Go sürüm 1'de değiştirilemez.\n\n## 🔘 Fonksiyonlar ve Metodlar (Structlar için fonksiyonlar)\n\n### ➡️ T ve \\* T'nin neden farklı metod atamaları var?\n\n[Go spesifikasyonunun](https://golang.org/ref/spec#Types) dediği gibi, T türünün metod kümesi, alıcı türü T olan tüm metodlardan oluşurken, karşılık gelen işaretçi türü _T, alıcı_ T veya \\*T olan tüm yöntemlerden oluşur. Bu, _\\*T yöntem kümesidir. T'yi içerir, ancak tersini içermez. Bu ayrım, bir arabirim değeri bir_ T işaretçisi içeriyorsa, bir yöntem çağrısı işaretçinin başvurusunu kaldırarak bir değer elde edebildiği için ortaya çıkar, ancak bir arabirim değeri bir T değeri içeriyorsa, bir işaretçi elde etmek için bir yöntem çağrısı için güvenli bir yol yoktur. (Bunu yapmak, bir yöntemin arayüz içindeki değerin içeriğini değiştirmesine izin verir ve bu, dil spesifikasyonu tarafından izin verilmemektedir.) Derleyicinin yönteme geçmek için bir değerin adresini alabildiği durumlarda bile, yöntem değeri değiştirirse, değişiklikler çağırıcıda kaybolur. Örnek olarak, bytes.Buffer'ın Write yöntemi bir işaretçi yerine bir değer alıcısı kullanıyorsa, bu kod:\n\n```go\nvar buf bytes.Buffer\nio.Copy(buf, os.Stdin)\n```\n\nstandart girdiyi `buf`'ın kendisine değil buf'ın bir `Copy` elemanına kopyalar. Bu neredeyse hiçbir zaman istenen davranış değildir.\n\n## 🔘 Kontrol Akışı\n\n### ➡️ Go neden ?: operatörüne sahip değil?\n\nGo'da üçlü test işlemi yoktur. Aynı sonucu elde etmek için aşağıdakileri kullanabilirsiniz:\n\n```go\nif expr {\n n = trueVal\n} else {\n n = falseVal\n}\n```\n\nGo'da olmayan ?:, dilin tasarımcılarının işlemin aşılmaz karmaşık ifadeler yaratmak için çok sık kullanıldığını görmeleridir. If-else formu, daha uzun olmasına rağmen, tartışmasız bir şekilde daha nettir. Bir dilin yalnızca bir koşullu kontrol akışı yapısına ihtiyacı vardır.\n\n## 🔘 Paketler ve Testing\n\n### ➡️ Nasıl çok dosyalı paket oluştururum?\n\nPaketin tüm kaynak dosyalarını tek başlarına bir dizine koyun. Kaynak dosyalar isteğe bağlı olarak farklı dosyalardan öğelere başvurabilir; ileri tanımlamalara veya bir başlık dosyasına gerek yoktur. Birden çok dosyaya bölünmek dışında, paket tek dosyalık bir paket gibi derlenecek ve test edilecektir.\n\n### ➡️ Nasıl birim testi yazarım?\n\nPaket kaynaklarınızla aynı dizinde `_test.go` ile biten yeni bir dosya oluşturun. Bu dosyanın içine, `\"testing\"` i içe aktarın ve formun işlevlerini yazın\n\n```go\nfunc TestFoo(t *testing.T) {\n ...\n}\n```\n\nBu dizindeyken `go test` komutunu çalıştırın. Bu komut dosyası Test fonksiyonlarını bulur, bir test ikili dosyası oluşturur ve çalıştırır.\n\nDaha fazla ayrıntı için [How to Write Go Code](https://golang.org/doc/code.html) belgesine, [testing](https://golang.org/pkg/testing/) paketine ve [go test](https://golang.org/cmd/go/#hdr-Test\\_packages) alt komutuna bakın.\n\n### ➡️ Test için en sevdiğim yardımcı fonksiyon nerede?\n\nGo'nun standart test paketi, birim testleri yazmayı kolaylaştırır, ancak onaylama işlevleri gibi diğer dillerin test çerçevelerinde sağlanan özelliklerden yoksundur. Bu belgenin daha önceki bir bölümü Go'nun neden iddialara sahip olmadığını ve aynı argümanlar testlerde assert kullanımı için de geçerli olduğunu açıkladı. Doğru hata işleme, biri başarısız olduktan sonra diğer testlerin çalıştırılmasına izin vermek anlamına gelir, böylece hatayı ayıklayan kişi neyin yanlış olduğunu tam olarak görebilir. İsPrime'ın 2, 3, 5 ve 7 (veya 2, 4, 8 ve 16 için) için yanlış cevap verdiğini rapor etmek, isPrime'ın 2 için yanlış cevap verdiğini ve bu nedenle hayır cevabını vermekten daha yararlıdır. daha fazla test yapıldı. Test hatasını tetikleyen programcı, başarısız olan koda aşina olmayabilir.\n\nİyi bir hata mesajı yazmak için harcanan zaman artık daha sonra test sona erdiğinde karşılığını veriyor. Bununla ilgili bir nokta, test çerçevelerinin, koşullu ifadeler, kontroller ve baskı mekanizmaları ile kendi mini dillerine dönüşme eğiliminde olmasıdır. ancak Go tüm bu yeteneklere zaten sahiptir; neden onları yeniden yarattın? Go'da testler yazmayı tercih ederiz; öğrenilmesi gereken daha az dildir ve bu yaklaşım, testleri basit ve anlaşılması kolay tutar.\n\nİyi hatalar yazmak için gereken ekstra kod miktarı tekrarlayıcı ve ezici görünüyorsa, test, bir veri yapısında tanımlanmış bir girdi ve çıktı listesi üzerinde yinelenen tabloya dayalıysa daha iyi çalışabilir (Go, veri yapısı değişmezleri için mükemmel bir desteğe sahiptir). İyi bir test ve iyi hata mesajları yazma işi daha sonra birçok test senaryosuna göre amortismana tabi tutulacaktır. Standart Go kitaplığı, fmt paketi için [biçimlendirme testleri gibi açıklayıcı örnekler](https://golang.org/src/fmt/fmt\\_test.go)le doludur.\n\n### ➡️ X neden standart kütüphanede yok?\n\nStandart kütüphanenin amacı, çalışma zamanını desteklemek, işletim sistemine bağlanmak ve biçimlendirilmiş G / Ç ve ağ iletişimi gibi birçok Go programının gerektirdiği temel işlevleri sağlamaktır. Ayrıca, kriptografi ve HTTP, JSON ve XML gibi standartlar için destek dahil olmak üzere web programlama için önemli öğeler içerir.\n\nNeyin dahil edileceğini tanımlayan net bir kriter yok çünkü uzun zamandır bu tek Go kütüphanesi idi. Bununla birlikte, bugün neyin ekleneceğini tanımlayan kriterler var. Standart kitaplığa yeni eklemeler nadirdir ve dahil etme çıtası yüksektir. Standart kitaplığa dahil edilen kod, büyük bir sürekli bakım maliyeti taşır (genellikle orijinal yazar dışındaki kişiler tarafından karşılanır), [Go 1 uyumluluk taahhüdü](https://golang.org/doc/go1compat.html)ne (API'deki herhangi bir kusur için engelleme düzeltmeleri) tabidir ve Go sürümüne tabidir.\n\nProgram, hata düzeltmelerinin kullanıcılara hızlı bir şekilde sunulmasını önler. Yeni kodların çoğu standart kitaplığın dışında yaşamalı ve [go tool](https://golang.org/cmd/go/) ile erişilebilir olmalıdır. git komuta al. Bu tür kodların kendi bakımcıları, yayın döngüsü ve uyumluluk garantileri olabilir. Kullanıcılar [godoc.org](https://godoc.org/) adresinde paketleri bulabilir ve belgelerini okuyabilir. Standart kütüphanede `log/syslog` gibi gerçekten ait olmayan parçalar olsa da, Go 1 uyumluluk vaadi nedeniyle kitaplıktaki her şeyi korumaya devam ediyoruz. Ancak çoğu yeni kodu başka bir yerde yaşamaya teşvik ediyoruz.\n\n## 🔘 İmplemantasyonlar\n\n### ➡️ Derleyicileri oluşturmak için hangi derleyici teknolojisi kullanılır?\n\nGo için birkaç üretim derleyicisi ve çeşitli platformlar için geliştirilmekte olan birkaç başka derleyici vardır. Varsayılan derleyici `gc`, go komutunun desteğinin bir parçası olarak Go dağıtımına dahildir. Gc, başlangıçta önyüklemenin zorlukları nedeniyle C dilinde yazılmıştır - bir Go ortamı kurmak için bir Go derleyicisine ihtiyacınız vardır. Ancak işler gelişti ve Go 1.5 sürümünden bu yana derleyici bir Go programı oldu. Derleyici, bu [tasarım belgesi](https://golang.org/s/go13compiler)nde ve konuşmada açıklandığı gibi otomatik çeviri araçları kullanılarak C'den Go'ya dönüştürüldü.\n\nBu nedenle, derleyici artık \"kendi kendine barındırılıyor\", bu da önyükleme sorunuyla yüzleşmemiz gerektiği anlamına geliyor. Çözüm, çalışan bir C kurulumunda olduğu gibi, çalışan bir Go kurulumuna sahip olmaktır. Kaynağından yeni bir Go ortamının nasıl ortaya çıkarılacağının hikayesi [burada](https://golang.org/s/go15bootstrap) ve [burada](https://golang.org/doc/install/source) anlatılmaktadır.\n\nGc, Go'da özyinelemeli bir iniş ayrıştırıcıyla yazılır ve yine Go'da yazılan ancak Plan 9 yükleyiciye dayanan özel bir yükleyici kullanır, ELF / Mach-O / PE ikili dosyaları oluşturmak için. Projenin başlangıcında gc için LLVM kullanmayı düşündük, ancak performans hedeflerimizi karşılamak için çok büyük ve yavaş olduğuna karar verdik. Geriye dönüp bakıldığında daha önemli olan, LLVM ile başlamak, Go'nun gerektirdiği ancak standart C kurulumunun bir parçası olmayan bazı ABI ve yığın yönetimi gibi ilgili değişiklikleri uygulamaya koymayı zorlaştırırdı. Ancak şimdi yeni bir [LLVM uygulaması](https://go.googlesource.com/gollvm/) bir araya gelmeye başlıyor.\n\n`Gccgo` derleyicisi, standart GCC arka ucuna bağlı özyinelemeli bir iniş ayrıştırıcısı ile C ++ ile yazılmış bir ön uçtur. Go'nun bir Go derleyicisini uygulamak için iyi bir dil olduğu ortaya çıktı, ancak asıl amacı bu değildi. Başından beri kendi kendine barındırılmaması, Go'nun tasarımının ağa bağlı sunucular olan orijinal kullanım durumuna odaklanmasına izin verdi. Go'nun kendisini erken derlemesine karar vermiş olsaydık, derleyici yapımı için daha çok hedeflenmiş bir dil bulabilirdik, bu değerli bir hedef ama sahip olduğumuz değil başlangıçta.\n\nGc bunları kullanmasa da (henüz), Go paketinde yerel bir sözcük ve ayrıştırıcı mevcuttur ve ayrıca yerel bir [tür denetleyici](https://golang.org/pkg/go/types) de vardır.\n\n### ➡️ Çalışma zamanı desteği nasıl uygulanır?\n\nYine, önyükleme sorunları nedeniyle, çalışma zamanı kodu başlangıçta çoğunlukla C ile yazılmıştır (küçük bir montajlayıcı ile), ancak o zamandan beri Go'ya çevrilmiştir (bazı assembler bitleri hariç). Gccgo'nun çalışma zamanı desteği `glibc` kullanır. Gccgo derleyicisi, altın bağlayıcıda yapılan son değişikliklerle desteklenen, segmentli yığınlar adı verilen bir teknik kullanarak gorutinleri uygular. `Gollvm` benzer şekilde ilgili `LLVM` altyapısı üzerine inşa edilmiştir.\n\n### ➡️ Basit programım neden büyük dosya boyutlu?\n\nGc araç zincirindeki bağlayıcı, varsayılan olarak statik bağlantılı ikili dosyalar oluşturur. Bu nedenle tüm Go ikili dosyaları, dinamik tür kontrollerini, yansımayı ve hatta panik zamanı yığın izlerini desteklemek için gerekli çalışma zamanı tür bilgileriyle birlikte Go çalışma zamanını içerir.\n\nLinux'ta `gcc` kullanılarak statik olarak derlenen ve bağlanan basit bir C \"merhaba, dünya\" programı, bir `printf` uygulaması da dahil olmak üzere yaklaşık `750 kB`'dir. `fmt.Printf` kullanan eşdeğer bir Go programı birkaç megabayt ağırlığındadır, ancak bu daha güçlü çalışma zamanı desteği ve tür ve hata ayıklama bilgileri içerir. Gc ile derlenen bir Go programı `-ldflags = -w` bayrağına bağlanarak `DWARF` oluşturmayı devre dışı bırakarak ikili dosyadan hata ayıklama bilgilerini kaldırabilir, ancak başka bir işlev kaybı olmaz. Bu, ikili boyutu önemli ölçüde azaltabilir.\n\n### ➡️ Kullanılmayan değişken/içe aktarım ile ilgili uyarıları durdurabilir miyim?\n\nKullanılmayan bir değişkenin varlığı bir hatayı gösterebilirken, kullanılmayan içe aktarmalar derlemeyi yavaşlatır, bir program zamanla kod ve programcıları biriktirdikçe önemli hale gelebilir. Bu nedenlerle Go, kullanılmayan değişkenler veya içe aktarmalar içeren programları derlemeyi reddeder, uzun vadeli oluşturma hızı ve program netliği için kısa vadeli kolaylık ticaretini yapar.\n\nYine de, kod geliştirirken, bu durumları geçici olarak oluşturmak yaygındır ve program derlenmeden önce bunları düzenlemenin gerekmesi can sıkıcı olabilir. Bazıları, bu kontrolleri kapatmak veya en azından uyarılara indirgemek için bir derleyici seçeneği talep etti. Böyle bir seçenek eklenmemiştir, çünkü derleyici seçenekleri dilin anlamını etkilememelidir ve Go derleyicisi uyarıları değil, yalnızca derlemeyi engelleyen hataları bildirdiği için. Hiçbir uyarı almamanın iki nedeni vardır. İlk olarak, şikayet etmeye değerse, kodu düzeltmeye değer. (Ve düzeltmeye değmiyorsa, buna değmez İkinci olarak, derleyicinin uyarılar oluşturması, uygulamayı, derlemeyi gürültülü hale getirebilecek zayıf durumlar hakkında uyarmaya ve düzeltilmesi gereken gerçek hataları maskelemeye teşvik eder. Yine de durumu ele almak kolaydır. Geliştirme sırasında kullanılmayan şeylerin devam etmesine izin vermek için boş tanımlayıcıyı kullanın.\n\n```go\nimport \"unused\"\n\n// This declaration marks the import as used by referencing an\n// item from the package.\nvar _ = unused.Item // TODO: Delete before committing!\n\nfunc main() {\n debugData := debug.Profile()\n _ = debugData // Used only during debugging.\n ....\n}\n```\n\nGünümüzde çoğu Go programcısı, [Goimports](https://godoc.org/golang.org/x/tools/cmd/goimports) adlı bir araç kullanıyor, bu da Go kaynak dosyasını doğru içe aktarmaları elde etmek için otomatik olarak yeniden yazıyor ve uygulamada kullanılmayan içe aktarma sorununu ortadan kaldırıyor. Bu program, bir Go kaynak dosyası yazıldığında otomatik olarak çalışması için çoğu düzenleyiciye kolayca bağlanır.\n\n### ➡️ Virüs tarama yazılımım neden Go dağıtımıma veya derlenmiş ikili dosyama virüs bulaştığını düşünüyor?\n\nBu, özellikle Windows makinelerde yaygın bir durumdur ve neredeyse her zaman yanlış bir pozitiftir. Ticari virüs tarama programları, diğer dillerden derlenenler kadar sık ​​görmedikleri Go ikili dosyalarının yapısı nedeniyle genellikle karıştırılır. Go dağıtımını yeni yüklediyseniz ve sistem virüs bulaştığını bildirirse, bu kesinlikle bir hatadır.\n\nGerçekten kapsamlı olmak için, sağlama toplamını [indirilenler sayfasındakil](https://golang.org/dl/)erle karşılaştırarak indirmeyi doğrulayabilirsiniz. Her durumda, raporun hatalı olduğuna inanıyorsanız, lütfen virüs tarayıcınızın tedarikçisine bir hata bildirin. Belki zamanla virüs tarayıcıları Go programlarını anlamayı öğrenebilir.\n\n## 🔘 Performans\n\n### ➡️ Go, X karşılaştırmasında neden kötü performans gösteriyor?\n\nGo'nun tasarım hedeflerinden biri, karşılaştırılabilir programlar için C'nin performansına yaklaşmaktır, ancak bazı kıyaslamalarda, [golang.org/x/exp/shootout](https://go.googlesource.com/exp/+/master/shootout/)'taki birkaçı da dahil olmak üzere, oldukça zayıf bir şekilde işliyor. En yavaş olanlar, karşılaştırılabilir performansın sürümlerinin Go'da bulunmadığı kütüphanlere bağlıdır. Örneğin, [pidigits.go](https://go.googlesource.com/exp/+/master/shootout/pidigits.go), çok duyarlıklı bir matematik paketine bağlıdır ve Go'nun aksine C sürümleri [GMP](https://gmplib.org/)'yi (optimize edilmiş derleyicide yazılmıştır) kullanır. Normal ifadelere (örneğin [regex-dna.go](https://go.googlesource.com/exp/+/master/shootout/regex-dna.go)) dayanan karşılaştırmalar, esasen Go'nun yerel [regexp paketi](https://golang.org/pkg/regexp)ni PCRE gibi olgun, yüksek düzeyde optimize edilmiş düzenli ifade kitaplıklarıyla karşılaştırıyor.\n\nKıyaslama oyunları kapsamlı ayarlamalarla kazanılır ve kıyaslamaların çoğunun Go sürümleri dikkat gerektirir. Karşılaştırılabilir C ve Go programlarını ölçerseniz ([reverse-complement.go](https://go.googlesource.com/exp/+/master/shootout/reverse-complement.go) bir örnektir), iki dilin ham performansta bu paketin gösterdiğinden çok daha yakın olduğunu göreceksiniz.\n\nYine de, iyileştirme için yer var. Derleyiciler iyidir ancak daha iyi olabilir, birçok kütüphane büyük performans çalışmasına ihtiyaç duyar ve çöp toplayıcı henüz yeterince hızlı değildir. (Öyle olsa bile, gereksiz çöp üretmemeye özen göstermenin çok büyük bir etkisi olabilir.)\n\nHer durumda, Go genellikle çok rekabetçi olabilir. Dil ve araçlar geliştikçe birçok programın performansında önemli gelişmeler olmuştur. Bilgilendirici bir örnek için [Go programlarını profilleme ](https://blog.golang.org/2011/06/profiling-go-programs.html)hakkındaki blog gönderisine bakın.\n\n## 🔘 C'den Değişiklikler\n\n### ➡️ Sözdizimi C'den neden bu kadar farklı?\n\nTanımlama sözdizimi dışında, farklılıklar büyük değildir ve iki arzudan kaynaklanır. İlk olarak, sözdizimi çok fazla zorunlu anahtar sözcük, tekrar veya gizem olmadan hafif hissetmelidir. İkinci olarak, dil analiz edilmesi kolay olacak şekilde tasarlanmıştır ve bir sembol tablosu olmadan ayrıştırılabilir. Bu, hata ayıklayıcılar, bağımlılık çözümleyicileri, otomatikleştirilmiş belge çıkarıcıları, IDE eklentileri vb. Gibi araçlar oluşturmayı çok daha kolaylaştırır. C ve onun soyundan gelenler bu bakımdan herkesin bildiği gibi zordur.\n\n### ➡️ Tanımlamalar neden ters yönlü yapılır?\n\nC'ye alışkınsanız, yalnızca geriye doğrudurlar. C'de, fikir bir değişkenin türünü ifade eden bir ifade gibi bildirilmesidir, bu güzel bir fikirdir, ancak tür ve ifade gramerleri çok iyi karışmaz ve sonuçlar kafa karıştırıcı olabilir; fonksiyon işaretlerini düşünün. Go, çoğunlukla ifade ve tür sözdizimini ayırır ve bu da işleri basitleştirir (işaretçiler için \\* öneki kullanmak, kuralı kanıtlayan bir istisnadır). C'de tanımlamalar\n\n```c\nint* a, b;\n```\n\nGo'da ise\n\n```go\nvar a, b *int\n```\n\nher ikisinin de işaretçi olduğunu beyan eder. Bu daha net ve daha düzenli. Ayrıca: = kısa tanımlama formu, tam değişken bildiriminin şu sırayı sunması gerektiğini savunur `: = değer`\n\n```go\nvar a uint64 = 1\n```\n\naşağıdaki ile aynı etkidedir.\n\n```go\na := uint64(1)\n```\n\nAyrıştırma, yalnızca ifade dilbilgisi olmayan türler için de farklı bir dilbilgisine sahip olarak basitleştirilmiştir; `func` ve `chan` gibi anahtar kelimeler her şeyi netleştirir. \n\nDaha fazla ayrıntı için [Go'nun Tanımlama Sözdizimi](https://golang.org/doc/articles/gos\\_declaration\\_syntax.html) hakkındaki makaleye bakın.\n\n### ➡️ Neden işaretçi aritmetiği yok?\n\nEmniyet. İşaretçi aritmetiği olmadan, hatalı bir şekilde başarılı olan geçersiz bir adresi asla türetemeyecek bir dil oluşturmak mümkündür. Derleyici ve donanım teknolojisi, dizi indekslerini kullanan bir döngünün işaretçi aritmetiği kullanan bir döngü kadar verimli olabileceği noktaya kadar gelişmiştir. Ayrıca, işaretçi aritmetiğinin olmaması, çöp toplayıcının uygulanmasını basitleştirebilir.\n\n### ➡️ Neden ++ ve -- tanımlama değilde ifadedir? Ve neden ön ek değilde son ektir?\n\nİşaretçi aritmetiği olmadan, ön ve sonek artırma operatörlerinin uygunluk değeri düşer. Bunları ifade hiyerarşisinden tamamen kaldırarak, ifade sözdizimi basitleştirilir ve ++ ve - (f (i ++) ve p \\[i] = q \\[++ i] 'yi düşünün) değerlendirme sırasına ilişkin karışık sorunlar da ortadan kaldırılır. . Sadeleştirme önemlidir. sonek ve öneke gelince, her ikisi de iyi çalışır, ancak son ek sürümü daha gelenekseldir; Önek ısrarı, adı ironik bir şekilde bir sonek artışını içeren bir dil kitaplığı olan STL ile ortaya çıktı.\n\n### ➡️ Neden parantez var ama noktalı virgül yok? Ve neden sonraki satırda açılış ayracı koyamazsınız?\n\nGo, C ailesindeki herhangi bir dille çalışan programcıların aşina olduğu bir sözdizimi olan ifade gruplaması için ayraç parantezleri kullanır. Ancak noktalı virgüller insanlar için değil, ayrıştırıcılar içindir ve biz onları olabildiğince ortadan kaldırmak istedik. Go, bu amaca ulaşmak için BCPL'den bir numara ödünç alır: İfadeleri ayıran noktalı virgüller biçimsel dilbilgisi içindedir, ancak bir ifadenin sonu olabilecek herhangi bir satırın sonuna sözcük yazar tarafından önden bakmadan otomatik olarak enjekte edilir.\n\nBu, pratikte çok iyi çalışır, ancak bir küme ayracı stilini zorlama etkisine sahiptir. Örneğin, bir işlevin açılış ayracı tek başına bir satırda görünemez. Bazıları, korsenin bir sonraki satırda yaşamasına izin vermek için lexer'in ileriye bakması gerektiğini savundu. Biz anlaşamadık. Go kodunun [gofmt](https://golang.org/cmd/gofmt/) tarafından otomatik olarak biçimlendirilmesi amaçlandığından, bazı stillerin seçilmesi gerekir. Bu stil, C veya Java'da kullandığınızdan farklı olabilir, ancak Go farklı bir dildir ve gofmt'nin stili diğerleri kadar iyidir.\n\nDaha önemli - çok daha da önemlisi - tüm Go programları için tek, programatik olarak zorunlu bir formatın avantajları, belirli bir stilin algılanan dezavantajlarından büyük ölçüde ağır basar. Go'nun stilinin, Go'nun etkileşimli bir uygulamasının standart sözdizimini özel kurallar olmaksızın her seferinde bir satır olarak kullanabileceği anlamına geldiğini unutmayın.\n\n### ➡️ Neden çöp toplama yapılıyor? Çok masraflı olmayacak mı?\n\nSistem programlarındaki en büyük muhasebe kaynaklarından biri, tahsis edilen nesnelerin yaşam sürelerini yönetmektir. Manuel olarak yapıldığı C gibi dillerde, önemli miktarda programcı zamanı tüketebilir ve genellikle zararlı hataların sebebidir. Yardımcı olmak için mekanizmalar sağlayan C ++ veya Rust gibi dillerde bile, bu mekanizmalar yazılımın tasarımı üzerinde önemli bir etkiye sahip olabilir ve genellikle kendi başına programlama ek yükü ekleyebilir. Bu tür programcı genel giderlerini ortadan kaldırmanın kritik olduğunu düşündük ve son birkaç yıldaki çöp toplama teknolojisindeki ilerlemeler, ağa bağlı sistemler için uygun bir yaklaşım olabileceğine dair yeterince ucuz ve yeterince düşük gecikme süresiyle uygulanabileceğine dair bize güven verdi.\n\nEşzamanlı programlamanın zorluğunun çoğunun kökleri nesne yaşam süresi problemine dayanır: nesneler iş parçacıkları arasında geçerken, güvenli bir şekilde serbest kalmalarını garanti etmek zahmetli hale gelir. Otomatik çöp toplama, eşzamanlı kodu çok daha kolay hale getirir yazmak. Elbette, eşzamanlı bir ortamda çöp toplamayı uygulamak başlı başına bir zorluktur, ancak bunu her programda değil bir kez karşılamak herkese yardımcı olur. Son olarak, eşzamanlılık bir yana, çöp toplama arabirimleri daha basit hale getirir çünkü bunlar arasında belleğin nasıl yönetildiğini belirtmelerine gerek yoktur. Bu, Rust gibi dillerde kaynakları yönetme sorununa yeni fikirler getiren son çalışmaların yanlış yönlendirildiği anlamına gelmez; bu çalışmayı teşvik ediyoruz ve nasıl geliştiğini görmekten heyecan duyuyoruz.\n\nAncak Go, yalnızca çöp toplama ve çöp toplama yoluyla nesne yaşam sürelerini ele alarak daha geleneksel bir yaklaşım benimsiyor. Mevcut uygulama, bir işaret ve süpür toplayıcıdır. Makine çok işlemcili ise, toplayıcı ana programla paralel olarak ayrı bir CPU çekirdeği üzerinde çalışır. Son yıllarda toplayıcı üzerinde yapılan büyük çalışma, büyük yığınlar için bile duraklama sürelerini sık sık milisaniyenin altındaki aralığa indirdi ve bu da çöplere yönelik başlıca itirazlardan birini ortadan kaldırıyor ağa bağlı sunucularda toplama. Algoritmayı iyileştirmeye, ek yükü ve gecikmeyi daha da azaltmaya ve yeni yaklaşımları keşfetmeye yönelik çalışmalar devam ediyor. Go ekibinden Rick Hudson'ın 2018 [ISMM açılış konuşması](https://blog.golang.org/ismmkeynote) şimdiye kadarki ilerlemeyi anlatıyor ve bazı gelecekteki yaklaşımlar öneriyor.\n\nPerformans konusuna gelince, Go'nun programcıya bellek düzeni ve tahsisi üzerinde, çöp toplama dillerinde tipik olandan çok daha fazla, hatırı sayılır bir kontrol sağladığını unutmayın. Dikkatli bir programcı, dili iyi kullanarak çöp toplama ek yükünü önemli ölçüde azaltabilir; Go'nun profil oluşturma araçlarının bir gösterimi de dahil olmak üzere, çalışılmış bir örnek için [Go programlarının profilini çıkarma](https://blog.golang.org/2011/06/profiling-go-programs.html) hakkındaki makaleye bakın.\n" }, { "path": "boeluem-1/tuer-doenuesuemue.md", "content": "# Tür Dönüşümü\n\nTür dönüşümü şu şekilde gerçekleştirilir.\n\n**`tür(değer)`**\n\nÖrnek olarak bakmak gerekir ise;\n\n```go\ni := 42\nf := float64(i)\nu := uint(f)\n```\n\nYukarıdaki yapılan işlemleri açıklayacak olursak eğer, **i** adında bir `int` değişken tanımladık. **f** adındaki değişkende **i** değişkenini `float64` türüne dönüştürdük. **u** adındaki değişkende ise **f** değişkenini `uint` türüne çevirdik.\n\nTüm türler arasında bu şekilde dönüşüm gerçekleştiremezsiniz. Bir sayıyı string tipine dönüştürmek istediğimizde ne olacağına bakalım.\n\n```go\ndeneme := string(8378)\nfmt.Println(deneme)\n```\n\n**deneme** adındaki değişkenimizin içinde **8378** sayısını **string** türüne dönüştürdük ve hemen aşağısına **deneme**’nin aldığı değeri ekrana bastırması için kodumuzu yazdık.\n\nAldığımız konsol çıktısı şu şekilde olacaktır.\n\n> ₺\n\nYani Türk Lirası simgesi çıkacaktır. Sayılar string türüne dönüştürüldüğünde karakter olarak değer alır.\n" }, { "path": "boeluem-1/veri-tipleri.md", "content": "# Veri Tipleri\n\n**Integer Türler**\n\nÖncelikle tüm integer türleri bir görelim;\n\nint, int8, int16, int32, int64\n\nuint, uint8, uint16, uint32, uint64, uintptr\n\nBu veri tipleri içerisinde sayısal değerleri depolayabiliriz. Fakat şunu da unutmamalıyız. Her sayısal veri tipinin depolayabildiği maksimum bit vardır. Örnek olarak uint8 veri tipinin maksimum uzunluğu 8 bit’tir. Bitler 0 ve 1 sayılarından oluşur. 8 bit demek 8 haneli 1 ve 0 sayısı demektir. Int8 maksimum alabileceği sayı derken 11111111 (8 tane 1), yani onluk sistemde 255 sayısına denk gelir. int 8 ise pozitif olarak +127, negatif olarak -128 maksimum değerinin alabilir. (127+128=255). int16 +32767 ve -32768 maksimum değerlerini alır. Int32 +2147483647 ve -2147483648 maksimum değerlerini alır. Int64 +9223372036854775807 ve -9223372036854775808 maksimum değerini alır.\n\nU harfi ile başlayan sayı veritiplerinde ise sayının değeri pozitif veya negatif işarette değildir. Sadece bir sayısal değerdir. U’nun anlamı unassigned yani işaretsizdir. Uint8 0-255 arası, uint16 0-65535, uint32 0-42967295 arası, uint64 0-18446744073709551615 arası değerler alabilir. Uintptr ise yazdığınız sayıya göre alanı belirlenir.\n\nInteger sayısal veri tipleri içierisinden bahsedebileceğimiz son tipler ise int ve uint. Int ve uint veri tipleri kullanmış olduğumuz işletim sistemi 32bit ise 32bit değer alırlar, 64bit ise 64bit değer alırlar. Sayısal bir değer atanacağı zaman en çok kullanılan veri tipleridir. Genellikle int daha çok kullanılır. Eğer çok meşakkatli bir program yazmayacaksanız int kullanmanız önerilir.\n\n**Byte Veri Tipi:** uint8 ile aynıdır.\n\n**Rune:** int32 ile aynıdır. Unicode karakter kodlarını ifade eder.\n\n**Float Türler**\n\nFloat türleri integer türlerden farklı olarak küsüratlı sayıları tutar. Örnek: 3.14\n\n**Lütfen Dikkat!**\n\nKüsüratlı sayılar İngiliz-Amerikan sayı sistemine göre nokta koyarak ifade edilir. Türk sistemindeki gibi virgül (3,14) ile ifade edilmez.\n\n**float32:** 32bitlik değer alabilir.\n\n**float64:** 64 değer alabilir.\n\n**Complex Türler**\n\nComplex türleri içerisinde gerçel küsüratlı (float) ve sanal sayılar barındırabilir. Türkçe’de karmaşık sayılar diye adlandırılır.\n\n**complex64:** Gerçel float32 ve sanal sayı değeri barındırır.\n\n**complex128:** Gerçel float64 ve sanal sayı değeri barındırır.\n\nSayısal türler bu şekildedir.\n\n**BOOLEAN VERİ TİPİ**\n\nBoolean yani mantıksal veri tipi bir durumun var olması halinde olumlu (true) değer, var olmaması halinde olumsuz (false) değer alan veri tipidir.\n\n**STRING VERİ TİPİ**\n\nString yani dizgi veri tipi içerisinde metinsel ifadeler barındırır. Örnek olarak “Golang çok güzel ama ingilicce”. String veri tipi değeri çift tırnak ( “Değer” ) içine yazılır. Diğer dillerdeki gibi tek tırnak ( ‘Değer’ ) insiyatifi yoktur. Tek tırnakla kullanım başka bir amaç içindir. İlerde onu da göstereceğim.\n\n**Özet olarak Veri Tipleri**\n\nVeri tipleri atanacak değerlerimizi RAM üzerinde depolamak için kullandığımız araçlardır. Tam sayı değerler için Integer veri tiplerini, ondalık sayılar için Float veri tiplerini, mantıksal değerler için Boolean veri tipini, metinsel değerler için String veri tipini kullanırız. Karmaşık sayı değerleri için ise Complex veri tipini kullanırız.\n\n”Türkiye” = String Tipi\n\n1881 = Integer Tipi\n\n10,5 = Float Tipi\n\nTrue = Boolean Tipi\n\n2+3i = Complex Tipi\n\n**Veri Tiplerinin Varsayılan Değerleri**\n\nVeri tipleri içerisine değer atanmadan oluşturulduğu zaman varsayılan bir değer alır.\n\nSayısal Tipler için 0,\n\nBoolean Tipi için false,\n\nString Tipi için “” (Boş dizgi) değeri alır.\n" }, { "path": "boeluem-1/vscode-varsayilan-hata-ayiklayiciyi-secme.md", "content": "# VSCode Varsayılan Hata Ayıklayıcıyı Seçme\n\nVSCode Go programlama yapıyorken, **F5** tuşuna bastığınızda üst tarafta hata ayıklayıcıyı seçmenizi ister. Her **F5** tuşuna bastığınızda hata ayıklayıcı seçim ekranı çıksın istemiyorsanız, yani herzaman bir hata ayıklayıcıyı kullansız istiyorsanız, yapacaklarınız çok basit.\n\nVSCode üzerinde ekranın sol tarafından **Run** sekmesine geçelim.\n\n![Adım.1](../.gitbook/assets/image.png)\n\nBiz varsayılan olarak **Go Hata Ayıklayıcısı**'nı seçeceğiz.\n\n**Go**'yu varsayılan hale getirmek içinse, ekranın solundan `create a launch.json file` bağlantısına tıklayalım.\n\n![Adım.2](../.gitbook/assets/defaultdebugger2.png)\n\nÜst tarafta açılan ekrandan **Go**'yu seçelim.\n\n![Adım.3](../.gitbook/assets/defaultdebugger1.png)\n\nSeçtikten sonra VSCode bizim için `launch.json` adında bir dosya oluşturacak. Bu dosya **F5** tuşuna bastığımızda gerçekleşecek olayları barındıryor. Dikkat edeceğimiz nokta **type** bölümünde **go** yazıyor olması.\n\n![Adım.4](../.gitbook/assets/defaultdebugger3.png)\n\nDaha sonra `launch.json` dosyamızı kaydedip kapatabiliriz.\n\nBir sonra hata ayıklama işleminde **Go** otomatik çalışacaktır.\n" }, { "path": "boeluem-1/yorum-satiri.md", "content": "# Yorum Satırı\n\nDiğer dillerde de olduğu gibi Golang’ta yorum satırı özelliği mevcuttur. Yorum satırı derleyici tarafından işlenmez. Yani görmezden gelinir. Bu bölüme kendiniz için açıklama vs. bilgiler yazabilirsiniz. Golang’ta yorum satırı oluşturmak için 2 yöntem mevcuttur.\n\n**// Çift Taksim Yöntemi**\n\nBu yöntem ile derlenmesini istemediğimiz yazının başına çift taksim ekleyerek görmezden gelinmesini sağlıyoruz.\n\n```go\n//Buraya herhangi birşey yazabilirsiniz\n```\n\n**/\\* \\*/ Taksim-Yıldız Yöntemi**\n\nBu yöntem ile birden fazla satırın derlemede görmezden gelinmesini sağlayabiliriz.\n\n```go\n/* Buraya\nherhangi\nbirşey\nyazabilirsiniz */\n```\n" }, { "path": "boeluem-2/anonim-fonksiyonlar.md", "content": "# Anonim Fonksiyonlar\n\nAnonim fonksiyonların en büyük özelliği isimsiz olmalarıdır. (Zaten adından da belli oluyor 🤔) Yazıldıkları yerde direkt olarak çalışırlar. Çalışırken diğer fonksiyonlardaki gibi parametre verilemediği için fonksiyonun sonuna parametre eklenerek çalışıtırılırlar. Örneğimizi görelim:\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tmetin := \"Merhaba Dünya\"\n\n\tfunc(a string) {\n\t\tfmt.Println(a)\n\t}(metin)\n}\n\n```\n" }, { "path": "boeluem-2/bos-tanimlayicilar.md", "content": "# Boş Tanımlayıcılar\n\nGolang kodlarımızda bazen 2 adet değer döndüren fonksiyonlar kullanırız. Bu değerlerden hangisini kullanmak istemiyorsak, değişken adı yerine **\\_ (alt tire)** kullanırız.\n\nÖrneğimizi görelim:\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc fonksiyonumuz(girdi int) (int, int) {\n\tişlem1 := girdi / 2\n\tişlem2 := girdi / 4\n\treturn işlem1, işlem2\n}\n\nfunc main() {\n\tikiyeböl, dördeböl := fonksiyonumuz(16)\n\tfmt.Println(ikiyeböl, dördeböl)\n}\n```\n\nGördüğünüz gibi fonksiyonumuzdan dönen iki değeri de değişkenlere atadık. Eğer birini atamak istemeseydik şöyle yapardık:\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc fonksiyonumuz(girdi int) (int, int) {\n\tişlem1 := girdi / 2\n\tişlem2 := girdi / 4\n\treturn işlem1, işlem2\n}\n\nfunc main() {\n\tikiyeböl, _ := fonksiyonumuz(16)\n\tfmt.Println(ikiyeböl)\n}\n```\n\nYukarıdaki kodlarımızda fonksiyonumuzun 4’e bölme özelliğini kullanmak istemediğimizden dolayı boş tanımlama işlemi yaptık.\n\nBoş tanımlama işlemleri çoğunlukla Golang’ta programcılar tarafından hata çıktısını kullanmak istenmediğinizde yapılıyor.\n" }, { "path": "boeluem-2/defer.md", "content": "# Defer\n\nDefer kelimesinin Türkçe’deki karşılığı **ertelemektir**. Bu deyimi yapacağımız işlemin başına eklersek o işlemi içerisinde bulunduğu fonksiyonun içindeki işlemlerden sonra çalıştırır. Çok karışık bir cümle kurdum ama uygulamaya geçince anlayacaksınız.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n defer fmt.Println(\"İlk Cümle\")\n fmt.Println(\"İkinci Cümle\")\n}\n```\n\nÇıktımız şu şekilde olacaktır;\n\n> İkinci Cümle\n>\n> İlk Cümle\n\nAçıklamaya gelirsek ekrana **İlk Cümle** yazısını bastıran satırımızın başına **defer** terimini ekledik. **defer** eklediğimiz satır **main()** fonksiyonunun içinde olduğu için **main()** fonsyionundaki tüm işlemler tamamlandıktan sonra ekrana yazımızı bastırdı.\\\nBirden fazla defer ekleyecek olursak;\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n defer fmt.Println(\"ilk Cümle\")\n defer fmt.Println(\"İkinci Cümle\")\n defer fmt.Println(\"Üçüncü Cümle\")\n defer fmt.Println(\"Dördüncü Cümle\")\n fmt.Println(\"Beşinci Cümle\")\n}\n```\n\nÇıktımız şu şekilde olacaktır;\n\n> Beşinci Cümle\n>\n> Dördüncü Cümle\n>\n> Üçüncü Cümle\n>\n> İkinci Cümle\n>\n> ilk Cümle\n\nBurdan anlıyoruz ki en baştaki defer eklenen satır en son işleme tabi tutuluyor. Hadi defer ile alakalı bir programlama alıştırması yapalım.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n fmt.Println(\"Sayıyor\")\n for i := 0; i < 10; i++ {\n  defer fmt.Println(i)\n }\n fmt.Println(\"Bitti\")\n}\n```\n\nÇıktımız şöyle olacaktır;\n\n> Sayıyor\n>\n> Bitti\n>\n> 9\n>\n> 8\n>\n> 7\n>\n> 6\n>\n> 5\n>\n> 4\n>\n> 3\n>\n> 2\n>\n> 1\n>\n> 0\n" }, { "path": "boeluem-2/doengueler.md", "content": "# Döngüler\n\nProgramlama ile uğraşan arkadaşlarımızın da bileceği üzere, programlama dillerinde **while, do while** ve **for** döngüleri vardır. Bu döngüler ile yapacağımız işlemin belirli koşullarda tekrarlanmasını sağlayabiliriz. Golang’ta ise diğer dillerin aksine sadece **for** döngüsü vardır. Ama bu **while** ve **do while** ile yapılanları yapamayacağımız anlamına gelmiyor. Golang’taki for döngüsü ile hepsini yapabiliriz. Yani dilin yapımcıları tek döngü komutu ile hepsini yapabilmemize olanak sağlamışlar.\n\nGelelim for döngüsünün kullanımına. Go’da for döngüsü parametreleri parantez içine alınmaz.\n\n**STANDART FOR KULLANIMI**\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tfor i := 0; i < 10; i++ {\n\t\tfmt.Println(i)\n\t}\n}\n```\n\n**Açıklaması:**\n\n**For** döngüsünden ayrı olarak **deger** adında **0** sayısal değerini alan bir değişken oluşturduk. **For** döngüsünde ise sadece koşul parametresini belirttlik. Yani döngü **deger** değişkeni **10** sayısından küçük olduğu zaman çalışacak. **For** kod bloğu içerisinde her döngü tekrarlandığında deger değişkeni ekrana basılacak ve deger değişkenine **+1** eklenecek.\n\nKonsol çıktımız şu şekilde olacaktır;\n\n> 0\n>\n> 1\n>\n> 2\n>\n> 3\n>\n> 4\n>\n> 5\n>\n> 6\n>\n> 7\n>\n> 8\n>\n> 9\n\n**SADECE KOŞUL BELİRTEREK KULLANMA**\n\nBu **for** yazım şekli while mantığı gibi çalışır. Parametrelerde sadece koşul belirtilir.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tdeger := 0\n\tfor deger < 10 {\n\t\tfmt.Println(deger)\n\t\tdeger++\n\t}\n}\n```\n\n**Açıklaması:**\n\n**For** döngüsünden ayrı olarak **deger** adında **0** sayısal değerini alan bir değişken oluşturduk. **For** döngüsünde ise sadece koşul parametresini belirttlik. Yani döngü **deger** değişkeni **10** sayısından küçük olduğu zaman çalışacak. **For** kod bloğu içerisinde her döngü tekrarlandığında deger değişkeni ekrana basılacak ve deger değişkenine **+1** eklenecek.\n\nKonsol çıktımız şu şekilde olacaktır;\n\n> 0\n>\n> 1\n>\n> 2\n>\n> 3\n>\n> 4\n>\n> 5\n>\n> 6\n>\n> 7\n>\n> 8\n>\n> 9\n" }, { "path": "boeluem-2/fonksiyon-cesitleri.md", "content": "# Fonksiyon Çeşitleri\n\nGolang’ta genel olarak 3 çeşit fonksiyon yapısı bulunmaktadır. Hemen bu çeşitleri görelim.\n\n**Variadic Fonksiyonlar**\n\nVariadic fonksiyon tipi ile fonksiyonumuza kaç tane değer girişi olduğunu belirtmeden istediğiniz kadar değer girebilirsiniz.\n\nHemen örneğimize geçelim.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc toplama(sayilar ...int) int {\n toplam := 0\n for _, n := range sayilar {\n toplam += n\n }\n return toplam\n}\n\nfunc main() {\n fmt.Println(toplama(3, 4, 5, 6)) //18\n}\n```\n\nYukarıdaki fonksiyonumuzu inceleyelim. Vereceğimiz sayıları toplaması için aşağıda **toplama** adında bir fonksiyon oluşturduk. Fonksiyonun parametresi içerisine, yani parantezler içerisine, **sayilar** isminde **int** tipinde bir değişken tanımladık. **…** (üç nokta) ile istediğimiz kadar değer alabileceğini belirttik. **toplam** değerini mantıken doğru değer vermesi için **0** yaptık. Çünkü her sayıyı toplam değikeninin üzerine ekleyecek.\n\n**range**’in buradaki kullanım amacından bahsedeyim. **range**’i **for** döngüsü ile kullandığımızda işlem yaptığımız öğenin uzunluğuna göre işlemimizi sürdürürüz. Yani fonksiyonumuzun içine ne kadar sayı eklersek işlemimiz ona göre şekillenecektir. For ve Range işlemini daha sonraki bölümümüzde göreceğiz.\n\n**Range** kullanımında **\\_, n** şeklinde değişken tanımlamamızın sebebi, birinci değişken yani **\\_**, dizinin indeksini yani sıra numarasını verir. Bizim bununla bir işimiz olmadığı için **\\_** koyarak kullanmayacağımızı belirttik. İkinci değişken ise yani **n** dizinin içindeki değeri verir yani fonksiyona girdiğimiz sayıları. Sonuç olarak bu fonksiyonda **return** ile **for** işleminden sonra tüm sayıların toplamını döndürüp **main()** fonksiyonu içerisinde ekrana bastırmış olduk.\n\n**Closure (Atanmış) Fonksiyonlar**\n\nClosure fonksiyonlar ile değişkenlerimizi fonksiyon olarak tanımlayabiliriz. Buradan anlamamız gereken şey fonksiyonların da atanabilen veri tipleri olduğudur. Örneğimize geçelim.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n toplam := func(x, y int) int {\n return x + y\n }\n fmt.Println(toplam(2, 3))\n}\n```\n\nYukarıdaki kodlarımızı inceleyecek olursak, **main** fonksiyonunun içine **toplam** adında bir değişken oluşturduk. Bu değişkenin türünün otomatik algılanması için **:=** işaretlerimizi girdik. Değişkene değer olarak anonim bir fonksiyon (ismi olmayan fonksiyon yani) yazdık. Bu fonksiyon **x** ve **y** adında iki tane **int** değer alıyor ve **return** kısmında bu iki değeri **int** olarak döndürüyor. Aşağıdaki **Println()** fonksiyonunda ise bu değişkeni aynı bir fonksiyonmuşcasına kullandık.\n\nAtanmış fonksiyonlar yöntemine benzer olarak, bir fonksiyon ile fonksiyon tipinde veri döndürerek de atayabiliriz.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tp := yazdır()\n\n\tp(\"Merhaba Dünya\")\n\n}\n\nfunc yazdır() func(s string) {\n\treturn func(s string) {\n\t\tfmt.Println(s)\n\t}\n}\n```\n\n**Recursive (Özyinelemeli) Fonksiyonlar**\n\nRecursive fonksiyonlar yazdığımız fonksiyonun içinde aynı fonksiyonu kullanmamız demektir. Fonksiyonumun tüm işlemler bittiğinde return olur. Örneğimize geçelim.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n fmt.Println(faktoriyel(4))\n}\n\nfunc faktoriyel(a uint) uint {\n if a == 0 {\n return 1\n }\n return a * faktoriyel(a-1)\n}\n```\n\nYukarıdaki fonksiyon ile bir sayının faktöriyelini hesaplayabiliriz. Faktöriyel hakkında kısaca bir hatırlatma yapayım. Belirlediğimiz sayıya kadar olan tüm sayıların sırasıyla çarpımınına o sayının faktöriyeli denir. Yani 4 sayısının faktöriyelini bulmak istiyorsak: 1\\_2\\_3\\*4 işlemini yaparız. Sonuç 24’tür.\n\nFaktöriyel fonksiyonun giriş ve çıkış tiplerini uint yapmamızın sebebi ise faktöriyel sonucunu bulmak için en geriye gidildiğinde eksi değerlere geçilmemesi içindir. Ayrıca sıfırın faktöriyeli birdir. Onun için değer sıfırsa bir return etmesini istedik. Faktöriyel fonksiyonunun en alttaki return kısmında girdiğimiz sayı ile girdiğimiz sayının bir eksiğinin faktöriyelini çarpacak. Girdiğimiz sayının bir küçüğünü bulmak içinse yeniden o sayının faktöriyelini hesaplayacak. Daha sonra aynı işlemler bu sayılar içinde yapılacak, ta ki sayı sona gelene yani en küçük uint değeri olan 0’a dayanana kadar. Daha sonra sonucu main fonksiyonu içerisinde ekrana bastırdık.\n" }, { "path": "boeluem-2/fonksiyonlar.md", "content": "# Fonksiyonlar\n\nFonksiyonlar içlerine parametre girilebilen ve işlemler yapabilen birimlerdir. Matematikteki fonksiyonlar ile aynı mantıkta çalışan bu birimlerden bir örneği inceleyelim.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc topla(a int, b int) int {\n\treturn a + b //a ve b’nin toplamını döndürür.\n}\n\nfunc main() {\n\tfmt.Println(topla(2, 5)) //2+5 sonucunu ekrana bastır\n}\n```\n\nYukarıdaki kodları ineleyecek olursak, foksiyonlarımızı oluşturmak için **func** anahtar kelimesini kullanırız. Yanına ise fonskiyonumuzun ismini yazarız. Parantez içine fonksiyonumuzun dışarıdan alacağı parametreler için değişken-tip tanımlaması yaparız. parantezin sağına ise fonksiyonun döndüreceği **return** değerinin tipini yazarız. Süslü parantezler içinde fonksiyonumuzun işlemleri bulunur. Son olarak return ile veri tipini belirlediğimiz değeri elde etmiş oluruz.\n\n**Main** fonksiyonu içerisinde **topla(2,5)** fonksiyonu ile 2 ve 5 sayısının toplamını ekrana bastırmış olduk. Yani ekrana 7 sayısı verildi.\n\nFonksiyonlar istendiği kadar parametre alabildiği gibi, istenirse parametresiz de olabilir. Fonksiyonları veri return etmek yerine bir işlem yaptırmak içinde kullanabiliriz.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc yazdir() {\n\tfmt.Println(\"yazı yazdırdık\")\n}\n\nfunc main() {\n\tyazdir()\n}\n```\n\n**yazdir** adlı fonsiyonumuzun parantezine değişken tanımlamadık ve parantezin sağına fonksiyon bloğu içerisinde **return** olmadığı için veri çıkış tipini belirtmedik. Fonksiyonumuzun içerisinde sadece ekrana yazı bastırdık.\n\n**Fonksiyonlar Hakkında Ayrıntılı Bilgiler**\n\nFonksiyon parantezi içerisine değişken tanımlanırken eğer tüm değişkenlerin türleri aynı ise sadece en sağdaki değişkenin tipini belirtmeniz yeterlidir. Örnek:\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc islem(sayi int) (x, y int) { //return’un degiskenlerini tanımladık\n\tx = sayi / 2\n\ty = sayi * 2\n\treturn //Burada sadece return yazıyor\n}\n\nfunc main() {\n\tfmt.Println(islem(10))\n}\n```\n\nYukarıda ise isimlendirilmiş **return** kullandık. return tipini yazdığımız paranteze bakacak olursa **(x, y int)** diyerek **return** edilecek verinin fonksiyonun blokları içerisinden çekilmesini sağladık. Böylece fonksiyon bloğununun sonundaki **return** kelimesinin yanına birşey yazmadık. Bu fonksiyonumuzun çıktısı ise **5 20** olacaktır.\n" }, { "path": "boeluem-2/if-else.md", "content": "# If-Else\n\nIf ve Else kelimelerinin Türkçe karşılığına bakacak olursak;\n\n**If :** Eğer, **Else :** Yoksa anlamına gelir. **If-Else** akışı koşullandırmalar için kullanılır. Diğer dillerin aksine koşul parametresi parantezler içine yazılmaz. Teorik kısmı bırakıp uygulama kısmına geçelim ki daha anlaşılır olsun\n\n```go\nif koşul {\n\t//Koşul sağlandığında yapılacak işlemler\n} else {\n\t//Koşul sağlanmadığında yapılacak işlemler\n}\n```\n\nYukarıdaki kod tanımına göre örnek bir program yazalım;\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n i := 5\n if i == 5 {\n  fmt.Println(\"i'nin değeri 5'tir.\")\n } else {\n  fmt.Println(\"i'nin değeri 5 değildir.\")\n }\n}\n```\n\nYukarıdaki kodları inceleyelim. i’nin değerini 5 verdik. `if` teriminin sağında i’nin 5 eşitliği koşulunu sorguladık. Eşitse ekrana \"i’nin değeri 5’tir.\" yazısını bastıracak. Değilse \"i’nin değeri 5 değildir.\" yazısı bastıracak. Bu yüzden i’nin değeri 5 olduğu için ekrana \"i’nin değeri 5’tir.\" yazısını bastırdı. If-Else akşında else kullanmamamız else’nin kod bloğunu boş bırakmamız ile aynı anlama gelir.\n\n```go\ni := 10\nif i==10 {\n fmt.Println(“i’nin değeri 10’dur.”)\n}\n```\n\nYukarıda sadece **if** deyimini girdik. **Else**’yi girmedik. Burada sonuçlanan olay, **i**’nin değeri **10**’a eşitse **i**’nin değeri **10**’dur. yazısını ekrana bastırır. **Else** deyimini girmediğimiz için şartın sağlanmaması durumunda hiçbir işlem gerçekleşmez. Çıktımız **i**’nin değeri **10**’a eşit olduğu için **i**’nin değeri **10**’dur. çıkar.\n\n**ELSE-IF KULLANIMI**\n\n**If-Else** akışında birden fazla koşul kontrolü ekleyebiliriz. Bunu **else if** deyimi ile yapabiliriz. Kısaca bakacak olursak;\n\n```go\ni := 5\nif i == 5 {\n fmt.Println(\"i'nin değeri 5'tir.\")\n} else if i==3{\n fmt.Println(\"i'nin değeri 3'tür.\")\n}else{\n fmt.Println(\"i'nin değeri belirsiz.\")\n}\n```\n\nelse if deyiminin yazılışını da gördük. Açıklamaya gelirsek, else if deyimi kendinden önceki deyimin koşulunun sağlanmaması halinde bir sonraki koşulu kontrol ettirir. If-Else akışında istenildiği kadar else if deyimi eklenebilir.\n\n\\\n**Koşullar İçerisinde Operatör Kullanımı**\\\nKoşullar içerisinden mantıksal ve ilişkisel operatörler kullanılabilir. Operatörleri görmüştük. Operatör kullanarak örnekler yapalım.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n i := 5\n a := 3\n b := 5\n if i != a { //Birinci Koşul\n  fmt.Println(\"i eşit değildir a\")\n }\n if i == b { //İkinci Koşul\n  fmt.Println(\"i eşittir b\")\n }\n if i == b && i > a { //Üçüncü Koşul\n  fmt.Println(\"i eşittir b ve i büyüktür a\")\n }\n}\n```\n\nÇıktımız şu şekilde olacaktır;\n\n> i eşit değildir a\n>\n> i eşittir b\n>\n> i eşittir b ve i büyüktür a\n" }, { "path": "boeluem-2/pointers-isaretciler.md", "content": "# Pointers (İşaretçiler)\n\nİşaretçiler ile nesnenin bellekteki adresi üzerinden işlemler yapabilir. Daha önceden işaretçileri içeren bir dil kullanmamış veya herhangi bir programlama dili de kullanmamış olabilirsiniz. Bu yüzden daha iyi anlamanız için işaretçilerin çalışma mantığını bilmemiz gerekir.\n\nÖrnek olarak `a` isminde bir değişkenimiz olsun. Bu değişkenimiz `tam sayı (int)` tipinde `8` değerini saklıyor olsun. Bu da Go dilinde aşağıdaki gibi oluyor.\n\n```go\nvar a int = 8\n```\n\nBu değişkenimizi oluşturduktan sonra programımız çalışmaya başlayınca işletim sistemimiz bu değişkene özel, **bellek (RAM)** üzerinde bir alan ayıracaktır. Programın geri kalanında değişkenimizin değerine bu alan üzerinden ulaşılacaktır. Yani bir değişken oluşturduğumuzda bellek üzerinde aşağıdaki resimdeki gibi bir alan oluştuğunu hayal edebilirsiniz.\n\n![Değişkenin RAM üzerindeki Alanı (Temsili)](../.gitbook/assets/pointeronram.png)\n\nYukarıdaki resimde mor renkli olarak gördüğümüz ifade ise değişkenimizin bellekteki adresidir. (Bu adres temsilidir. Zaten sürekli olarak değişen birşeydir.)\n\n## Peki Go'da işaretçileri nasıl kullanırız?\n\nBir program senaryosu belirleyelim. Bu programımızda yukarıdaki gibi `a` isminde `int` tipinde `8` değerini tutan bir değişkenimiz olsun. Ve `a` değişkenimize `5` ekleyen bir fonksiyonumuz olsun. Son olarak `a`'yı ekrana bastıralım.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := 8\n\tekle(a)\n\tfmt.Println(a)\n\t//sonucumuz yine 8 olacak\n}\nfunc ekle(v int) {\n\tv += 5\n}\n```\n\nYukarıdaki örnekte `a` değişkenini ekrana bastırdığımızda sonucun hala `8` olduğunu görüyoruz. Halbuki `ekle` fonksiyonunun içerisinde gördüğümün gibi `5` ekliyoruz.\n\n`a` değişkeninin değişmeme sebebi şudur:\\\n`ekle` fonksiyonunun parametresi olarak `int` tipinde `v` değişkenini oluşturduk. `v` değişkenimiz aslında `a`'dan gelen değeri kullanmamızı sağlıyor. Yani bize `a`'nın kendisini vermiyor. O yüzden `v` üzerinde değişiklik yaptığımızda `a`'ya yansımayacaktır.\n\n`a` değişkenini değiştirebilmemiz için bize `a`'nın bellekteki adresi gerekiyor. Bunun için de `&` (ampersand) işaretini kullanabiliriz.\n\n![Ampersand kullanımı](../.gitbook/assets/ampkullanımı.png)\n\nÖrnek vermek gerekirse:\n\n```go\nfunc main() {\n\ta := 8\n\tfmt.Println(&a) //Çıktımız: 0xc0000b8010\n}\n```\n\nArtık `a`'nın bellekteki adresini öğrenebiliyoruz. Sıra geldi bu adres üzerinden `a`'nın değerine ulaşabilmeye.\n\nBunun için de `*` (yıldız) işaretini kullanabiliriz.\n\n```go\nfunc main() {\n\ta := 8\n\tfmt.Println(&a) //Çıktımız: 0xc0000b8010\n\tb := &a\n\tfmt.Println(b) //Çıktımız: 0xc0000b8010\n\tfmt.Println(*b) //Çıktımız: 8\n}\n```\n\nYukarıdaki örneği incelediğimizde `b` değişkenine `a`'nın adresini atadık. `b`'yi bastırdığımızda `a`'nın bellekteki adresini görebiliriz. Aynı zamanda `*b` şeklinde kullanarak `a`'nın içindeki değere de ulaşabiliriz. Bu durumda a ve bdeğişkenleri aynı bellek alanını temsil ediyorlar.\n\n`a` değişkenine `b` üzerinden değişiklik yapmak için aşağıdaki yöntemi uygulayabilirsiniz.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := 8\n\tb := &a\n\t*b = 10\n\tfmt.Println(a) //10\n}\n```\n\nEn başta kurguladığımız senaryoyu işaretçiler ile kolayca yapabiliriz.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := 8\n\tekle(&a)\n\tfmt.Println(a) //Çıktımız: 13\n}\nfunc ekle(v *int) {\n\t*v += 5\n}\n```\n\nYukarıdaki örneği incelediğimizde, `ekle` fonksiyonumuzu oluştururken parametre olarak verdiğimiz `v` değişkeninin tipinde önce `*` işareti koyduk. Bunun sebebi `v` değişkeni ile fonksiyonumuza gelecek olan adresin içindeki değere ulaşabilmektir.\n\n`ekle` fonksiyonunun içerisindeki `v`'yi kullanırken de başına `*` koyarak kullandık.\n\n`main` fonksiyonumuzda `ekle` fonksiyonunu çağırırken de `a` değişkenini `&` işareti kullanarak bellekteki adresi ile verdik.\n\nBu sayede `a` değişkenine bellekteki adresi ile müdahale etmiş olduk.\n" }, { "path": "boeluem-2/switch.md", "content": "# Switch\n\nSwitch kelimesinin Türkçe’deki anlamı **anahtardır**. Switch deyimi de if-else deyimi gibi koşul üzerine çalışır. Yine teorik kısmı geçip anlaşılır olması için örnek yapalım. **case** deyimi durumu ifade eder. Koşul sağlandığı zaman işleme devam edilmez.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n i := 5\n switch i {\n  case 5:\n   fmt.Println(\"i eşittir 5\")\n  case 10:\n   fmt.Println(\"i eşittir 10\")\n  case 15:\n   fmt.Println(\"i eşittir 15\")\n }\n}\n```\n\nÇıktımız şu şekilde olacaktır;\n\n> i eşittir 5\n\nSwitch’te koşulların gerçekleşmediği zaman işlem uygulamak istiyorsak bunu **default** terimi ile yaparız. Örnek;\n\n```go\ni := 5\nswitch i {\n case 5:\n  fmt.Println(\"i eşittir 5\")\n default:\n  fmt.Println(\"i bilinmiyor\")\n}\n```\n\n### **Koşulsuz Switch**\n\nSwitch’in tanımını daha iyi anlayabilmeniz için koşulsuz switch kullanımına örnek verelim. Bu yöntemde switch deyiminin yanına koşul girmek yerine case deyiminin yanına koşul giriyoruz.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n i := 5\n switch {\n  case i == 5: //i=5 olduğu için diğer case’ler sorgulanmaz\n   fmt.Println(\"i eşittir 5\")\n  case i < 10:\n   fmt.Println(\"i küçüktür 10\")\n  case i > 3:\n   fmt.Println(\"i büyüktür 3\")\n }\n}\n```\n\nÇıktımız şu şekilde olacaktır;\n\n> i eşittir 5\n\n### Sonraki Koşulu Kontrol Ettirme\n\nDurumlar içerisinde kontrol etmemiz gereken başka durumlarda olabilir. Bunun için **fallthrough** deyimini kullanabiliriz.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tx := 5\n\tswitch {\n\tcase x == 5:\n\t\tfmt.Println(\"x 5'tir\")\n\t\tfallthrough\n\tcase x < 10:\n\t\tfmt.Println(\"x 10'dan küçüktür\")\n\n\t}\n}\n```\n\nÇıktımız aşağıdaki gibi olacaktır.\n\n> x 5'tir\\\n> x 10'dan küçüktür\n\n### Switch'e Özel Değişken Tanımlama\n\nTıpkı If deyimindeki gibi Switch içerisinde de kullanabileceğimiz değişkenler tanımlayabiliriz.\n\n```go\nswitch x := 5; {\n\tcase x == 5:\n\t\tfmt.Println(\"x 5'tir\")\n\tcase x < 10:\n\t\tfmt.Println(\"x 10'dan küçüktür\")\n}\n```\n" }, { "path": "boeluem-3/anonim-struct-metodlar.md", "content": "# Anonim Struct'lar\n\nGolang’ta tıpkı anonim fonksiyonlar olduğu gibi anonim struct methodlar da oluşturabiliriz. Örneğimizi görelim:\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n kişi := struct {\n ad, soyad string\n }{\"Kemal\", \"Atatürk\"}\n fmt.Println(kişi)\n}\n```\n\nYukarıda struct’ı bir değişken içerisinde tanımladık. Bunu normal struct method olarak yazmaya kalksaydık aşağıdaki gibi yazardık.\n\n```go\npackage main\nimport \"fmt\"\ntype insan struct {\n ad, soyad string\n}\nfunc main() {\n kişi := insan{\"Kemal\", \"Atatürk\"}\n fmt.Println(kişi)\n}\n```\n" }, { "path": "boeluem-3/arayuez-interface.md", "content": "# Interface\n\n**Interface** (arayüz), nesne yönelimli programlama dilllerine aşina olmayan kişiler için biraz zor anlaşılan bir konu. Aslında buraya kadar anlattığım konularda mantık olarak anlamadığınız bir yer yoksa interface konusunu anlayabileceğinizi düşünüyorum. Önemli olan güzelce anlatabilmem. O yüzden gelecekten gelen ben, bu eskimiş ve yeni başlayanlar için pek anlaşılabilir olmayan bu konunun anlatımına yeniden bir el atıyorum.\n\nÖncelikle interface'in Golang üzerindeki tanımı: Interface, farklı tasarlanmış ama sonuç olarak aynı amaç için kullanılan structlar için bir standart tanımlamasıdır. (Size şuan ne kadar geçti bu tanım bilemem 🤔)\n\nTamamen gerçek hayattan bir örnek ile benzetme yapayım. Bu yazıyı yazarken biraz karnım aç olduğu için tamamen şuan aklıma gelen gıda üzerinden bir örnek ile ilerleyeceğim.\n\nBizim bir tane normal bir konserve salçamız ve bir tane da biber salçamız olduğunu düşünün.\n\nAşağıdaki resimde daha önce tarihte örneği görülmemiş bir şema ile karşılaşacaksınız. Lütfen hazırlıklı olun.\n\n![](../.gitbook/assets/salca.png)\n\nYukarıdaki ilginç şemadan çıkarmamız gereken ders, altta bulunana konserve salçaların ikisinde de `ye()` isminde fonksiyonları var. Bunları struct fonkisyon olarak eklenmiş gibi düşünün.\n\nYukarıdaki `Salça` interface'imizin ise ye() isminde bir fonksiyon tanımlaması var. Aslında burada struct fonksiyonlar gibi bir fonksiyon tanımlamıyoruz. Burada anlatılmak istenen olay, `salça` interface'i içerisinde bir salçanın salça olabilmesi için `ye()` fonksiyonunun olması gerekir diyoruz. Yani interface'imiz bir bakıma `Türk Standartları Enstitüsü` gibi birşey :relaxed: Yani biz bir salçalı ekmek yiyeceğimiz zaman `Salça` interface'imize bakıyoruz ve görüyoruz ki TSE tarafından belirlenmiş olarak `ye()` fonksiyonu bulunan bir salça almamız gerekiyor. Şemadaki 2 çeşit salçanın da `ye()` fonksiyonu olduğu için ikisi de `salça` interface'inde belirlenmiş standart(lar)a uygun oluyor.\n\nŞimdi bunun için bir örnek görelim.\n\n```go\ntype biberSalçası struct {\n\t//buraya birşey yazmamız gerekli değil\n}\n\nfunc (s biberSalçası) Ye() {\n\tfmt.Println(\"Biber salçası yenildi\")\n}\n\ntype domatesSalçası struct {\n\t//buraya birşey yazmamız gerekli değil\n}\n\nfunc (s domatesSalçası) Ye() {\n\tfmt.Println(\"Domates salçası yenildi\")\n}\n```\n\nYukarıdaki 2 çeşit salça structı içinde `Ye()` struct fonksiyonları oluşturduk. Bu fonksiyonlar çeşidine göre komut satırına farklı çıktılar bastırıyor. Yani biz bu structlar üzerinden değişkenler oluşturup `Ye()` fonksiyonunu çalıştırabiliriz. Bir adım ilerleyelim.\n\n```go\ntype Salça interface{\n\tYe()\n}\n```\n\nYukarıda `Salça` isminde bir interface oluşturduk. Daha önceden oluşturduğumuz structlar bu interface'imizle uyumludur. Bunu nereden anladık, çünkü struclarımızın `Ye()` fonksiyonları var ve interface'imizde `Ye()` fonksiyonu olacak diye şart koşmuşuz. Main fonksiyonumuz ise aşağıdaki gibi olsun.\n\n```go\nfunc main() {\n\tbiber := biberSalçası{}\n\n\tvar salçam Salça\n\tsalçam = &biber\n\n\tsalçam.Ye()\n}\n```\n\nBu kısma dikkat edelim. biber isminde `biberSalçası` structından bir nesne oluşturduk. Sonrasında salçam isminde `Salça` interface'inden bir nesne oluşturduk.\n\n5\\. satırda ise `salçam` interface nesnesine biber structını atadık. Bu sayede `salçam` değişkeni üzerinden `biberSalçası` structının `Ye()` fonksiyonunu çalıştırabildik.\n\nProgramı çalıştırdığımızda aşağıdaki çıktıyı göreceğiz.\n\n> Biber salçası yenildi\n\nGördüğünüz gibi `biberSalçasının` `Ye()` fonksiyonunu çalıştırdı. Yani interface'imiz burada `biberSalçası` olarak çalıştı. Bir küçük örnek daha görelim.\n\n```go\nfunc main() {\n\tbiber := biberSalçası{}\n\tdomates := domatesSalçası{}\n\n\tvar salçam Salça\n\n\tsalçam = &biber\n\tsalçam.Ye()\n\n\tsalçam = &domates\n\tsalçam.Ye()\n}\n```\n\nYukarıdaki örneğimizde iki tür salça içinde bir değişken oluşturduk. Daha sonra interface'imiz için bir değişken oluşturduk.\n\nSonrasında interface değişkenimize `biberSalçasını` verip ekrana bastırdık, son olarak da interface değişkenimize `domatesSalçasını` verip ekrana bastık.\n\nSonuca baktığımızda iki farklı struct tipi içinde `Ye()` fonksiyonunda olan işlemleri gerçekleştirdi.\n\nÇıktımız aşağıdaki gibi olacaktır.\n\n> Biber salçası yenildi\n>\n> Domates salçası yenildi\n\nŞuanki yaptıklarımızdan farklı bir kullanım şekli de görelim.\n\n```go\nfunc Ye(s Salça){\n\ts.Ye()\n}\n\nfunc main() {\n\tbiber := biberSalçası{}\n\tdomates := domatesSalçası{}\n\n\tYe(biber)\n\tYe(domates)\n}\n```\n\nYukarıdaki kodlarımız daha yukarıdaki kodlarımızın devamıdır. Sadece farklı bir kullanım şekli. `Ye()` isminde bir fonksiyon oluşturduk. Bu fonksiyonun ismini farklı birşey de yapabilirdik. Neyse, fonksiyonumuza baktığımızda `Salça` interface'si ve bu interface'in standartlarına uygun olan değikenleri parametre olarak alabiliyor. Bu gelen parametreyi de `s` değişkeni üzerinden nesnenin `Ye()` fonksiyonunu çağırıyor.\n\n`Main` fonksiyonumuz içerisinden oluşturduğumuz nesleri `Salça` interface'inde belirtilen standartlara uygun olduğu için `Ye()` fonksiyonumuza parametre olarak verebildik.\n\nÇıktımıza bakalım bir de.\n\n> Biber salçası yenildi\n>\n> Domates salçası yenildi\n" }, { "path": "boeluem-3/dilimler-slices.md", "content": "# Dilimler (Slices)\n\nDilimler bir dizideki değerlerin istediğimiz bölümünü kullanmamıza yarar. Yani diziyi bir pasta olarak düşünürsek kestiğimiz dilimi yiyoruz sadece. Örneğimize geçelim.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n a := [6]int{2, 3, 5, 6, 7, 9}\n fmt.Println(a) //Çıktımız: [2 3 5 6 7 9]\n var b []int = a[2:4] //Dilimleme işlemi\n fmt.Println(b) //Çıktımız: [5 6]\n}\n```\n\nİnceleme kısmına geçelim. `a` isminde 6 tane `int` tipinde değer alan bir dizi oluşturduk. Çıktımızın içeriğini görmek için ekrana bastırdık. Dilimleme işlemi olarak yorum yaptığım satırda ise `a` dizisinde `2` ve `4` indeksi arasındaki değerleri dizi olarak b’ye kaydettik. b dizisinin içeriğini ekrana bastırdığımızda ise dilimlenmiş alanımızı gördük. Dilimleme işleminde `[ ]` içerisine dilimlemenin başlayacağı ve biteceği indeksi yazarız.\n\n**Dilim Varsayılanları (Sıfır Değerleri)**\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n a := [6]int{2, 3, 5, 6, 7, 9}\n var b []int = a[:4] //Boş bırakılan indeks 0 varsayıldı\n fmt.Println(b) //Çıktımız: [2 3 5 6]\n var c []int = a[3:] //Boş bırakıldığı için 3. index ve sonrası alındı\n fmt.Println(c) //Çıktımız: [6 7 9]\n}\n```\n\n**Dilim Uzunluğu ve Kapasitesi**\\\nBir dilimin **uzunluk** ve **kapasite** değeri vardır. Dilimin uzunluğunu **len()** fonksiyonu ile, kapasitesini ise **cap()** fonksiyonu ile hesaplarız. Örneğimize geçelim.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n a := [6]int{2, 3, 5, 6, 7, 9}\n b := a[2:4]\n fmt.Println(\"a uzunluk\", len(a))\n fmt.Println(\"a kapasite\", cap(a))\n fmt.Println(\"a'nın içeriği\", a)\n fmt.Println(\"b uzunluk\", len(b))\n fmt.Println(\"b kapasite\", cap(b))\n fmt.Println(\"b'nin içeriği\", b)\n}\n```\n\nb dizisi ile a dizisini dilimlediğimiz için b dizisinin kapasitesi ve uzunluğu değişti. Uzunluk dizinin içindeki değerlerin sayısıdır. Kapasite ise dizinin maksimum alabileceği değer sayısıdır. Çıktımıza bakacak olursak;\n\n> a uzunluk 6 \n>\n> a kapasite 6 \n>\n> a'nın içeriği \\[2 3 5 6 7 9] \n>\n> b uzunluk 2 \n>\n> b kapasite 4 \n>\n> b'nin içeriği \\[5 6]\n\n**Boş Dilimler (Nil Slices)**\\\nBoş bir dilimin varsayılan (sıfır) değeri **nil**’dir. Örnek olarak;\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n var a []int\n if a == nil {\n  fmt.Println(\"Boş\")\n }\n}\n```\n\nÇıktısı tahmin edeceğiniz üzere **Boş** yazısı olaraktır.\n\n\\\n**Make ile Dilim Oluşturma**\\\nDilimler **make** fonksiyonu ile de oluşturulabilir. Dinamik büyüklükte diziler oluşturabiliriz.\n\n```go\na := make([]int, 5)\n```\n\nBurada make fonksiyonu ile uzunluğu 5 olan a adında bir dizi oluşturduk.\n\n```go\na := make([]int, 0, 5)\n```\n\nBurada ise make fonksiyonu ile uzunluğu 0, kapasitesi ise 5 olan a adında bir dizi oluşturduk.\n\n\\\n**Dilime Ekleme Yapma**\\\nBir dilime ekleme yapmak için append fonksiyonu kullanılır. Hemen bir örnek ile kullanılışını görelim.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n var a []string\n fmt.Println(a) //[ ]\n a = append(a, \"Ali\")\n a = append(a, \"Veli\")\n fmt.Println(a) //[Ali Veli]\n}\n```\n\na isminde string tipinde boş bir dizi oluşturduk. Hemen ardından boş olduğunu teyit etmek için a dizisini ekrana bastırdık. Daha sonra a dizisine append fonksiyonu ile “Ali” değerini ekledik. Yine aynı yöntem ile “Veli” değerini de ekledik. Son olarak a dizisinin çıktısının ekrana bastırdığımızda değerlerin eklenmiş olduğunu gördük.\n\n```go\nfmt.Println(len(a), cap(a))\n```\n\na dizisinin uzunluk ve kapasitesine baktığımızda aşağıdaki çıktıyı alırız.\n\n> 2 2\n" }, { "path": "boeluem-3/diziler-arrays.md", "content": "# Diziler (Arrays)\n\nDiziler içlerinde bir veya birden fazla değer tutabilen birimlerdir. Bir dizideki her değer sırasıyla numaralandırılır. Numaralandırma sıfırdan başlar. Aynı şekilde örneğe geçelim.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n var a [3]string\n a[0] = \"Ayşe\" //Birinci değer\n a[1] = \"Fatma\" //İkinci değer\n a[2] = \"Hayriye\" //Üçüncü değer\n fmt.Println(a) //Çıktımız: [Ayşe Fatma Hayriye]\n fmt.Println(a[1])//Çıktımız: Fatma\n}\n```\n\nGelelim kodlarımızın açıklamasına. **a** isminde içerisinde 3 tane **string** tipinde değer barındırabilen bir dizi oluşturduk. a dizisinin birinci değerine yani **0** indeksine **“Ayşe”** atadık. 1 ve 2 indeksine ise “Fatma” ve “Hayriye” değerlerini atadık. a dizisini ekrana bastırdığımızda köşeli parantezler içinde dizinin içeriğini gördük. a’nın 1 indeksindeki değeri bastırdığımızda ise sadece 1 indeksindeki değeri gördük. Dizinin değerlerini tek tek olarak atayabileceğimiz gibi diziyi tanımlarken de değişkenlerini atayabiliriz.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n a := [3]string{\"Ayşe\", \"Fatma\", \"Hayriye\"}\n fmt.Println(a) //Çıktımız: [Ayşe Fatma Hayriye]\n}\n```\n" }, { "path": "boeluem-3/generics.md", "content": "# Generics\n\nBu sayfada Go geliştiricilerin _\"Go'da niye generics yok...Go'ya generics nezaman eklenecek?\"_ diye diye Go dilinin yaratıcılarına adeta hayatı zindan ettiği Generic'leri inceleyeceğiz. Generics Go'nun 1.18 versiyonu ile dile dahil edildi.\n\nGenerics olmadan da uzun süre boyunca Go yazmak mümkündü tabi ki. Peki bu kadar istenilen bu yapının bize ne gibi faydaları bulunuyor bir bakalım.\n\nUfak bir örnek ile başlayalım.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar sayı1 int = 5\n\tfmt.Println(arttır(sayı1))\n}\n\nfunc arttır(sayı int) int {\n\treturn sayı + 1\n}\n```\n\nYukarıdaki kodlarda basit bir ekleme işlemi yapan bir fonksiyon var. Bu fonksiyonumuz `int` değer alıyor ve `int` değer döndürüyor.\n\nBu fonksiyonumuza `int` tipinde `sayı1` değişkenimizi verdik ve ekrana bastırdık. Neyse zaten kod basit kendini açıklıyor ama nedense ben hep bu dökümanın başından beri herşeyi açıklıyorum. Bazı arkadaşlarımız bu yüzden bana kızıyor olabilir :relaxed:\n\nEğer `sayı1` değişkenimiz `int` değil de `float64` tipinde olsaydı, arttır fonksiyonumuzu değiştirmemiz gerekirdi. Eğer birden fazla sayı tipi ile işlem yapacağımız durumlar olsaydı, her biri için farklı fonksiyonlar eklememiz gerekecekti.\n\nGeneric'ler ile nasıl yapabileceğimizi görelim.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar sayı1 int = 5\n\tvar sayı2 float64 = 5.3\n\tfmt.Println(arttır(sayı1))\n\tfmt.Println(arttır(sayı2))\n}\n\nfunc arttır[n int | float64](sayı n) n {\n\treturn sayı + 1\n}\n```\n\n`main` bloğunun içinde baktığımızda farklı değişken tipindeki 2 sayıyı aynıyı fonksiyona parametre olarak verdik.\n\nBunu nasıl yaptığımız büyük bir sır değil tabiki. Biraz daha aşağıya baktığımızda kendini belli ediyor. `arttır` fonksiyonunun parametre parantezlerinden önce köşeli parantez açarak, bu kısma `n` isminde `int` veya `float64` tipinde değer alabilen bir tip oluşturduk. Fonksiyonumuzun parametre parantezinde `n` tipi ile belirlediğimiz tipte değerler alabilir hale geldik.\n\nYukarıdaki örneğimizde oluşturduğumuz generic fonksiyonda parametre tiplerinde kısıtlama yaptık.\n" }, { "path": "boeluem-3/map.md", "content": "# Map\n\n**Map**’in Türkçe karşılığında yapacağı işlemi anlatan bir çeviri olmadığı için anlamı yerine yaptığı işi bilelim. Map ile bir değişken içerisindeki dizileri bölge olarak ayırabiliriz. Çok karmaşık bir cümle oldu. O yüzden örneğimize geçelim ki anlaşılır olsun.\n\n```go\npackage main\nimport \"fmt\"\ntype insan struct {\n kisi1, kisi2, kisi3 string\n}\nfunc main() {\n var m map[string]insan\n m = make(map[string]insan)\n m[\"isim\"] = insan{\n  \"Ali\", \"Veli\", \"Ahmet\",\n }\n fmt.Println(m[\"isim\"])\n}\n```\n\nYukarıda **insan** isminde bir **struct** metodu oluşturduk ve içerisine **string** tipinde 3 tane değişken girdik. **main()** fonksiyonumuz içerisinde ise **m** adında **map** kullanarak **string** değer saklayabilen **insan** tipinde değişken oluşturduk. **m** değişkenini **make** ile **map dizisi** haline getirdik. Hemen aşağısında ise **m** değişkenine **“isim”** adında bir bölge oluşturduk ve **insan** **struct**’ında belirttiğimiz gibi 3 tane **string** değer girdik. Son olarak **m** dizisinin isim bölgesindeki değerleri ekrana bastırmasını istedik. Çıktımız şöyle olacaktır;\n\n> {Ali Veli Ahmet}\n\n**Birden Fazla Bölge Ekleme**\\\nÖnceki yazımızda map ile dizilere bölgesel hale getirmeyi gördük. Şimdi de birden fazla bölgeyi nasıl yapacağımızı göreceğiz. Örneğimize geçelim.\n\n```go\npackage main\nimport \"fmt\"\ntype insan struct {\n kisi1, kisi2, kisi3 string\n}\nvar m = map[string]insan{\n \"erkekler\": insan{\"Ali\", \"Veli\", \"Ahmet\"},\n \"kadinlar\": insan{\"Ayşe\", \"Fatma\", \"Hayriye\"},\n}\nfunc main() {\n fmt.Println(m[\"erkekler\"])\n fmt.Println(m[\"kadinlar\"])\n fmt.Println(m)\n}\n```\n\nYukarıda önceki örneğimizdeki gibi **insan struct**’ı oluşturduk ve içine **3** tane **string** tipinde değer atadık. **m** adında dizi oluşturduk ve **map** ile bölgeli bir dizi olduğunu belirttik. Dizinin içerisine **“erkekler”** isminde **insan** tipinde bir bölge oluşturduk ve içine **3** tane **string** tipinde değerimizi girdik. Aynı işlemi **“kadinlar”** isimli bölge içinde yaptık. **main** fonksiyonumuz içerisinde **erkekler** ve **kadinlar** bölgemizi ekrana bastırdık. Son olarak **m** dizisindeki tüm içeriği ekrana bastırık.\\\nÇıktımız ise şöyle olacaktır;\n\n> {Ali Veli Ahmet}\\\n> {Ayşe Fatma Hayriye}\\\n> map\\[erkekler:{Ali Veli Ahmet} kadinlar:{Ayşe Fatma Hayriye}]\n\nBurada ayrıntıyı farkedelim. **m** dizisini ekrana bastırdığımızda map yeni bölgeli bir dizi olduğunu vurguluyor. Map ile bir bakıma dizi içerisine yeni bir dizi ekliyorsunuz. Tabi bunu **struct metodu** ile yapıyoruz.\n\n\\\n**Bölgesel Silme İşlemi**\\\n**delete** fonksiyonu ile silme işlemimizi yapabiliriz. Hemen örneğimize geçelim.\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n m := make(map[string]int) //m isminde string bölge isimli int değer taşıyan dizi\n m[\"sayi\"] = 25 //sayi bölgesine 25 değerini yerleştirdik\n fmt.Println(m[\"sayi\"]) //Çıktımız: 25\n delete(m, \"sayi\") //sayi bölgesindeki değeri sildik\n fmt.Println(m[\"sayi\"]) //Çıktımız: 0 (sıfır)\n}\n```\n" }, { "path": "boeluem-3/range.md", "content": "# Range\n\n**Range**, üzerinde kullanıldığı diziyi **for** döngüsü ile tekrarlayabilir. Bir dilim range edildiğinde, tekrarlama başına iki değer döndürür (return). Birinci değer dizinin **indeksi**, ikinci değer ise bu indeksin içindeki **değerdir**. Örneğimize geçelim.\n\n```go\npackage main\nimport \"fmt\"\nvar isimler = []string{\"Ali\", \"Veli\", \"Hasan\", \"Ahmet\", \"Mehmet\"}\nfunc main() {\n for a, b := range isimler {\n  fmt.Printf(\"%d. indeks = %s\\n\", a, b)\n }\n}\n```\n\nYukarıdaki yazdığımız kodları açıklayalım. **isimler** isminde içerisinde **string** tipinde değerler olan bir **dizi** oluşturduk.\\\nFor döngümüz ile dizinimizdeki değerleri sıralayacak bir sistem oluşturduk. Döngümüzü açıklayacak olursak, bahsettiğimiz gibi dizi üzerinde uygulanan **range** terimi iki değer döndürecek olduğundan bu değerleri kullanabilmek için **a** ve **b** adında argüman belirledik. **range** **isimler** diyerek **isimler** dizisini kullanacağımızı belirttik. Ekrana bastırma bölümümüzde ise **%** işaretleri ile sağ taraftan hangi değerleri nerede kullanacağımızı belirttik.\\\nÇıktımız ise şu şekilde olacaktır.\n\n> 0. indeks = Ali\n> 1. indeks = Veli\n> 2. indeks = Hasan\n> 3. indeks = Ahmet\n> 4. indeks = Mehmet\n" }, { "path": "boeluem-3/struct-fonksiyonlar-methodlar.md", "content": "# Struct Fonksiyonlar (Methodlar)\n\nBu bölümde bir struct'a özel nasıl fonksiyon oluşturacağımızı göreceğiz.\n\nÖrneğimizi görelim:\n\n```go\npackage main\n\nimport \"fmt\"\n\ntype insan struct {\n\tisim string\n\tyaş int\n}\n\nfunc (i insan) tanıt() {\n\tfmt.Printf(\"Merhaba, Ben %s. %d yaşındayım.\", i.isim, i.yaş)\n}\nfunc main() {\n\tkişi := insan{\"Kaan\", 23}\n\tkişi.tanıt()\n}\n```\n\n`insan` isminde bir struct tipi oluşturduk. Bu yapımızın tıpkı insanlarda olduğu gibi `isim` ve `yaş` değişkenleri var.\n\nHemen aşağısında bir fonksiyon oluşturduk. Bu fonksiyonumuzun özelliği ise fonksiyonun isminden önce parantez içerisinde hangi struct'ta çalışacağını belirtmemizdir. `insan` struct'ının içerindeki değişkenlere ise `i` değişkeni ile eriştik.\n\nDaha sonra `main` fonksiyonumuzda `kişi` isminde `insan` tipinde bir nesne oluşturduk. `kişi.tanıt()` yazarak `insan` struct tipinde oluşturduğumuz nesne için olan `tanıt` fonksiyonumuzu çalıştırdık.\n\nÇıktımızı görelim:\n\n> Merhaba, Ben Kaan. 23 yaşındayım.\n\nTabii burada, `fmt.Prtinf` fonksiyonu içerisinde kullanılan `%s` ve `%d` ifadelerinini anlamamış olabilirsiniz. Bu ifadeler, fonksiyonun ilk argümanından sonra verilen değişkenlerin karakter dizisi (string) içerisinde kullanılabilmesine olanak sağlar. Veri tipi olarak `%s` kullanıldığı durumlarda string türü verileri, `%d` kullanıldığı durumlarda ise integer türü verilerin yerleştirileceğini belirtir. Doğru veri tipi için ifade seçilmediği durumlarda program hata vermeyecek ancak doğru çalışmayacaktır.\n\nBu konuya, ileride `String Formatlama` bölümünde değineceğiz.\n" }, { "path": "boeluem-3/struct.md", "content": "# Struct\n\nGo programlama dilinde sınıflar yoktur. Sınıflar yerine struct'lar (yapılar) vardır. Yapılar sayesinde bir nesne oluşturabilir ve bu nesneye ait özellikler oluşturabiliriz. Örnek bir struct oluşturalım.\n\n{% code title=\"struct örneği\" %}\n```go\ntype kişi struct {\n\tisim string\n\tsoyİsim string\n\tyaş int\n}\n```\n{% endcode %}\n\n`type` terimi ile yeni bir tür oluşturabiliyoruz. İsmini `kişi` olarak verdik ve türünün de `struct` olacağını söyledik. Yukarıdaki şekilde bir yapı oluşturmuş olduk. Bu yapı içerisinde `isim`, `soyİsim` ve `yaş` değişkenlerine sahip. Yukarıdaki yapı üzerinden bir nesne örneği oluşturduğumuzda örneğimiz bu değişkenlere sahip olacak.\n\n{% code title=\"Örnek Kullanım:\" %}\n```go\npackage main\n\nimport \"fmt\"\n\ntype kişi struct {\n\tisim string\n\tsoyİsim string\n\tyaş int\n}\n\nfunc main() {\n\n\tkişi1 := kişi{\"Kaan\", \"Kuşcu\", 23}\n\n\tfmt.Println(kişi1)\n\n}\n```\n{% endcode %}\n\n`main()` fonksiyonunun içerisini incelediğimizde, `kişi1` isminde `kişi{}` yapısında bir nesne örneği oluşturuyoruz. İçerisine oluşturucu parametreler olarak `kişi struct`'ındaki sıralamayı göz önünde bulundurarak parametrelerimi giriyoruz. Daha sonra kişi1 nesne örneğini ekrana bastırıyoruz. Çıktımız aşağıdaki gibi olacaktır:\n\n> {Kaan Kuşcu 23}\n\nYukarıdaki örnekte nesneyi tanımlama sırasında değer atamasını yaptık. Nesnenin alt değişkenlerine ulaşarak da tanımlama yapabilirdik.\n\n```go\nkişi1 := kişi{\"Kaan\", \"Kuşcu\", 23}\nkişi1.isim = \"Ahmet\"\nkişi1.soyİsim = \"Karaca\"\nkişi1.yaş = 34\n\nfmt.Println(kişi1) //{Ahmet Karaca 34}\n```\n\nNesne örneğini oluşturuyorken parametreleri boş bırakıp sonradan da atama yapabilirdik.\n\n```go\nkişi1 := kişi{}\nkişi1.isim, kişi1.soyİsim = \"M. K.\", \"ATATÜRK\"\nkişi1.yaş = 999\n\nfmt.Println(kişi1) //{M. K. ATATÜRK 999}\n```\n\n## İsim Belirterek Tanımlama\n\nNesneye özel değişkenleri tanımlarken değişken ismini belirterek de tanımlama yapabiliriz.\n\n```go\nkişi1 := kişi{soyİsim: \"Kuşcu\", isim: \"Kaan\", yaş: 23}\n\nfmt.Println(kişi1) //{Kaan Kuşcu 23}\n```\n\nDeğişken ismini belirterek atama yaptığımız için sıralamaya dikkat etmemiz gerekli değildir.\n" }, { "path": "boeluem-4/anonim-goroutine-fonksiyonlar.md", "content": "# Anonim Goroutine Fonksiyonlar\n\nBu yazımız **Goroutine** ve **Kanallar** dersi için biraz alıştırma tadında olacak.\\\n \\\nDaha önceki yazılarımızda belirli bir fonksiyonu **Goroutine** ile **asenkron** (eş zamanlı) olarak çalıştırmayı gördük. Bu yazımızda da **anonim** bir Goroutine fonksiyonunu göreceğiz. Bu fonksiyonun özelliği bir ismi olmaması ve asenkron olarak çalışmasıdır. Örneğimizi görelim.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"time\"\n)\nfunc main() {\n\tgo func() {\n\t\ttime.Sleep(time.Second * 2)\n fmt.Println(\"İlk yazımız\")\n\t}()\n\tfmt.Println(\"İkinci yazımız\")\n}\n```\n\nAçıklamasına gelirsek **go func()** ile anonim bir fonksiyon oluşturduk. Bu tür fonksiyonda fonksiyonumuzun sonuna **( )** parantezlerimizi yerleştirmek zorundayız. Çünkü fonksiyonumuza parametreleri bu parantezler içerisinde yolluyoruz. Şuanlık parametre yollamadığımzın için boş kalacak. Bu fonksiyonumuz programın geri kalanı ile aynı zamanda çalışacak. Hatta programın geri kalanı ile bağlantısı bile olmayacak. Bu sebepten ötürü mantıken 2 saniye sonra işlem yapmasını belirttiğimiz için **“İkinci yazımız”** metni gözüktükten sonra **“İlk yazımız”** metni gözükeceğini tahmin etsekte **go func()** fonksiyonu yapısı gereği zaman bağımsız çalışacağı için **fmt.Println(“İkinci yazımız”)** fonksiyonu tamamlandıktan sonra **“İlk yazımız”** metni ekrana bastırılmayacaktır bile. İsterseniz programı çalıştırıp deneyebilirsiniz.\\\nBunun önüne geçebilmein yolu **go func()** fonksiyonundaki işlemlerin programın çalışma zamanı içerisinde sonuç vermesidir.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"time\"\n)\nfunc main() {\n\tgo func() {\n\t\ttime.Sleep(time.Second * 2)\n\t\tfmt.Println(\"İlk yazımız\")\n\t}()\n\tfmt.Println(\"İkinci yazımız\")\n\ttime.Sleep(time.Second * 3)\n}\n```\n\nYukarıdaki mantıkla çalışması için zamanı böyle ayarlamamız gerekir. Ama bu yöntem çok boş (gereksiz) bir yöntemdir. Her zaman böyle zamanı tahmin edemeyiz. Örnek olarak, **go func()** fonksiyonunda internet üzerinden bir dosyanın inmesini bekleyecek olsaydık tahmini bir zaman belirleyemezdik. Ki koskoca Windows bile belirleyemiyor. Çünkü bu internet hızımız ile alaklı bir şeydir. Bu yüzden garanti bir yöntem değildir.\n\n\\\nBundan %100 daha garantili olan yöntem **kanallar** üzerinden haberleşmektir. Çünkü bir yerde kanal ataması yapıldığında program akışının devam edebilmesi için mutlaka kanaldan gelecek verinin beklenmesi gerekir. Bu sayede zaman ile alakalı işlerde tahmin yürütmemize gerek kalmaz. Biraz uzun bir açıklama oldu ama örneğimizi görünce mantığını anlayacaksınız.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"time\"\n)\nfunc main() {\n\tkanal := make(chan string) //kanal oluşturuyoruz\n\tgo func() {\n\t\ttime.Sleep(time.Second * 2) //2 saniye uyku\n\t kanal <- \"Kanal bitti\" //İletişime geçiriyoruz\n\t\tfmt.Println(\"Anonim fonksiyon yazısı\")\n\t}()\n\tfmt.Println(\"Öylesine bir yazı\")\n\tfmt.Println(<-kanal) //kanaldan gelen veri bekleniyor\n}\n```\n\nÖncelikle kanal ile ilgili işlemler yapabilmek için **make** fonksiyonu ile kanal oluşturduk. Hemen altında kanalımızı iletişime sokmak için öylesine bir **string** değer yolladım.\n\n\\\n**go func()** fonksiyonumuz yukarıdaki örnekler ile aynıdır. Bu fonksiyonumuzun 2 saniye beklemesi olduğundan dolayı fonksiyonumuzun altındaki **“Öylesine bir yazı”** daha önce görüntülenecek. Buraya kadar ilk örnek ile aynı olayla sonuçlanıyor. Programın sonlanmasını engellemek için **<- kanal** içinden değeri bastırarak kanal iletişimini beklemesini ve bundan dolayı **“Anonim fonksiyonu yazısı”**‘nı da beklemiş oluyoruz.\\\n \\\nAnonim Goroutine fonksiyonları bu şekilde kullanabiliriz.\n" }, { "path": "boeluem-4/kanallar-channels.md", "content": "# Kanallar (Channels)\n\n**Kanallar**, Go dilinde asenkron programlama yaparken değer aktarımı yapabileceğimiz hatlardır. Kanala değer atanması iş parçacığı tarafından bekleneceği için asenkron işlemler arasındaki senkronizasyonu ayarlayabiliriz. Kanallar `make()` fonksiyonu ile oluşturulur.\n\n{% code title=\"Örnek\" %}\n```go\nk := make(chan bool)\n```\n{% endcode %}\n\nYukarıdaki örnekte `make()` fonksiyonu ile `k` isminde bir kanal oluşturduk. Bu kanalın özelliği `bool` tipinde değer taşımasıdır. Yani bu kanal ile `true` veya `false` değerlerini taşıyabiliriz. Kanala değer göndermek için `<-` işaretini kullanırız. Yani bir nevi atama işlemi yapıyoruz. Atama işleminden farkı, kanala atama işlemi yapılana kadar iş parçacığının devam etmemesidir.\n\n{% code title=\"Örnek Atama\" %}\n```go\nk <- true\n```\n{% endcode %}\n\nAtama işlemi ile kanalımıza değer yolladık. Bir de bu kanalın çıkış noktası olması gerekir. Bu çıkış noktasında, ister kanaldan gelen veriyi bir değişkene atayabiliriz, istersek de sadece kanala veri gelmesini bekleyebiliriz.\n\n{% code title=\"Kanaldan gelen değeri değişkene atama\" %}\n```go\na := <-k\n```\n{% endcode %}\n\nYukarıdaki örnekte `a` isimli değişkene `k` kanalından gelen `bool` tipinde değer atadık. `a` değişkenine atama işlemi `k` kanalına değer gönderildiği zaman yapılacaktır. Yani `k` kanalına değer gelene kadar iş parçacığı duraklatılacaktır. _(Program `k` kanalına gelecek değeri bekler.)_\n\n{% code title=\"Sadece kanala değer gelmesini beklemek\" %}\n```go\n<- k\n```\n{% endcode %}\n\nYukarıdaki anlatılanlardan yola çıkarak bir örnek oluşturalım.\n\n{% code title=\"Örnek kanal işlemleri\" %}\n```go\npackage main\n\nimport (\n\t\"time\"\n)\n\nfunc main() {\n\n\t//bir kanal oluşturalım\n\tk := make(chan bool)\n\t//bu kanalımız bool değer taşıyacak\n\n\t//asenkron bir iş parçacığı oluşturalım\n\tgo func() {\n\t\t\n\t\t//bu iş parçacığı 5 sn beklesin\n\t\ttime.Sleep(time.Second * 5)\n\n\t\t//k kanalına bool bir değer gönderelim\n\t\tk <- true\n\t}()\n\n\t//ana iş parçacığı k kanalına değer gelene kadar bekleyecek\n\t<-k\n\t//değer geldiğinde program sonlanacaktır.\n}\n```\n{% endcode %}\n\n## Boyutlu Kanal Oluşturma\n\nOluşturduğumuz kanala boyut vermek de mümkün. Yani kanalımıza birden fazla değer yollayabiliyoruz. Bunun için kanalı oluştururken `make()` fonksiyonunda boyutu da belirtelim.\n\n{% code title=\"Örnek\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\nfunc main() {\n\n\t//2 adet bool değer taşıyan bir kanal oluşturalım\n\tk := make(chan bool, 2)\n\t\n\n\t//asenkron bir iş parçacığı oluşturalım\n\tgo func() {\n\n\t\t//5 sn beklesin\n\t\ttime.Sleep(time.Second * 5)\n\n\t\t//k kanalına bool bir değer gönderelim\n\t\tk <- true\n\n\t\t//tekrardan 2 sn beklesin\n\t\ttime.Sleep(time.Second * 2)\n\n\t\t//ve k kanalına 2. değer de gönderilsin.\n\t\tk <- false\n\t}()\n\n\t//ana iş parçacığı k kanalına 2 değer gelene kadar bekleyecek\n\tfmt.Println(<-k, <-k) //çıktı: true false\n\t//iki bool değeri de baştırmak için k kanalını 2 defa yazdık\n}\n```\n{% endcode %}\n\nAna iş parçacığı _(`main()` içerisine yazılan kodlar)_ devam etmek için `k` kanalına gelen 2 değeri de bekleyecektir.\n\n`fmt.Println()` içerisine sadece bir defa `<-k` yazsaydık, `k` kanalına ilk gelen değeri ekrana bastıracaktı.\n" }, { "path": "boeluem-4/mutex-ile-asenkron-islem-sirasi.md", "content": "# Mutex ile Asenkron İşlem Sırası\n\nSize konu başlığını şöyle açıklayayım. Örneğin bir banka uygulaması para çekme ve yatırma gibi özelliklere sahiptir. Programlama mantığında para yatırmak ve çekmek için mevcut para miktarını bilmemiz gerekir. Banka uygulamasının mantığı en basit derecede bu şekilde çalışır.\n\nBanka hesabımızda asenkron işlem yapıldığını varsayalım. Yani bir hesaptan aynı anda birden fazla kullanıcı işlem yapıyor olsun.\n\nÖrneğin hesabımızda 100₺ olsun. Birinci kullanıcı 20₺ yatırsın. Aynı anda ikinci kullanıcı 50₺ çeksin. Bu iki kullanıcınında kullandığı program işlem yapmaya başladığında önce para miktarını alıyor. Daha sonra yapılacak işleme göre ya ekleme ya da çıkarma işlemi yapıyor. Fakat birden fazla kullanıcı aynı anda bu işlemi yaparsa hesaptaki parada yanlışlık olacaktır.\n\nBasit bir görsel ile inceleyelim.\n\nİşlemlere aynı anda başlandığını varsayalım.\n\n![Örnek asenkron işlem](../.gitbook/assets/mutex.png)\n\nBu işlemin sonuncunda hangi kullancının işlemi sonuncu olarak biterse para miktarı onun sonucu olur. Yani kullanıcı 2'nin işlemi kullanıcı 1'den sonra biterse yeni para miktarı 50₺ olur.\n\nBu gibi örneklerde asenkron işlemlere sıra verilmesi gerekir. Mutex tam olarak bu işi yapıyor. Bunun için bir Mutex nesnesi oluşturuyoruz. İşlemlerimizi bu nesne üzerinden yapıyoruz. Bu nesne aynı anda sadece bir işlemi gerçekleştiriyor. Bu yüzden sıra işlemi sağlıyor. Önce başlayan asenkron işlem ilk sırada oluyor. Tamamlanınca diğerine sıra geçiyor. Böyle düşündüğümüz zaman \"bunun senkron programlamadan ne farkı var?\" diyebilirsiniz. Farkı asenkron fonksiyonların içindeki istediğimiz kısımları senkron çalıştırmamız.\n\nÖrnek bir para yatırma-çekme uygulaması yazalım. İşlemin sağlık çalışması için, para miktarıyla aynı anda sadece bir kişi işlem yapabilmelidir.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"sync\" // mutex'i kullanmak için\n)\n//global olarak mutex nesnesi oluşturalım.\nvar mt sync.Mutex\n\n\nfunc paraÇek(bakiye *float64, çekilecekMiktar float64, wg *sync.WaitGroup) {\n\t/*\n\t* mt isimli mutex'i bu işlem yapılırken kilitliyoruz.\n\t* bu sayede mt mutex'ini başka işlemler kullanamıyor.\n\t*/\n\tmt.Lock()\n\n\t/*\n\tbu kısımda asenkron olmasını istemediğimiz işlemi yapalım.\n\t*/\n\t*bakiye -= 15\n\tfmt.Printf(\"Yeni Bakiye: %.2f\\n\", *bakiye)\n\n\t/*\n\t* diğer işlemlerinde kullanabilmesi için mutex'i tekrardan açalım.\n\t* mt mutex açılınca diğer asenkron işlemdeki mt mutex'i çalışmaya başlar. \n\t*/\n\tmt.Unlock()\n\tfmt.Println(\"Çekme işlemi tamamlandı.\")\n\n\t/*\n\t* waitgroup ile işlemin tamamlandığını belirttik.\n\t* böylece wg havuzu 2'den 1'e düştü\n\t*/\n\twg.Done()\n}\n\n//bu fonksiyonda yukarıdaki ile aynı mantıkta\nfunc paraYatır(bakiye *float64, yatırılacakMiktar float64, wg *sync.WaitGroup) {\n\tmt.Lock()\n\t*bakiye += 65\n\tfmt.Printf(\"Yeni Bakiye: %.2f\\n\", *bakiye)\n\tmt.Unlock()\n\tfmt.Println(\"Yatırma işlemi tamamlandı.\")\n\twg.Done()\n}\n\nfunc main() {\n\n\t/*\n\t* asenkron işlemlerimizin, ana iş parçacığında tamamlanmasını\n\t* beklemek için waitgroup nesnesi oluşturalım\n\t*/\n\tvar wg sync.WaitGroup\n\n\t//2 fonksiyonu da bekleyeceğimiz için Add'e 2 yazalım\n\twg.Add(2)\n\n\t//fonksiyonlarımızın kullancağı bakiye değişkenimiz\n\tvar bakiye float64 = 100\n\tfmt.Printf(\"İlk Bakiye: %.2f\\n\", bakiye)\n\t\n\t/*\n\t* paraÇek ve paraYatır fonksiyonlarımızı aynı anda başlatıyoruz.\n\t* hangisi daha önce başlarsa mutex sırasına ilk o girer. bu esnada diğer\n\t* fonksiyon mutex'in açılmasını bekler.\n\t*/\n\tgo paraÇek(&bakiye, 25, &wg)\n\tgo paraYatır(&bakiye, 65, &wg)\n\n\t/*\n\t* ana iş parçacığı tamamlandığında asenkron çalışan fonksiyonları beklemez.\n\t* beklemediğinde de asenkron fonksiyonlar çalışmadan program sonlanır.\n\t* ana iş parçacığının asenkron işlemleri beklemesi için waitgroup sonucunun 0 olmasını bekleriz.\n\t* wg.Add(2) yazarak 2 adet wg.Done() fonksiyonu çalıştığında wg.Add(0) olur ve\n\t* wg.Wait() tamamlanır ve program başka işlemler yapılmıyor ise sonlanır.\n\t*/\n\twg.Wait()\n}\n```\n\nÇıktımız aşağıdaki gibi olacaktır.\n\n> İlk Bakiye: 100.00\\\n> Yeni Bakiye: 165.00\\\n> Yatırma işlemi tamamlandı.\\\n> Yeni Bakiye: 150.00\\\n> Çekme işlemi tamamlandı.\n\nYukarıdaki çıktıya göre, `paraYatır()` fonksiyonu `paraÇek()` fonkisyonundan önce çalışmıştır.\n" }, { "path": "boeluem-4/select.md", "content": "# Select\n\n**Select** ile çoklu goroutine işlemlerinin iletişimini bekleyebiliriz. Örneğimizi görelim:\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"time\"\n)\nfunc main() {\n\tk1 := make(chan string)\n\tk2 := make(chan string)\n\tgo func() {\n\t\ttime.Sleep(time.Second * 1)\n\t\tk1 <- \"video\"\n\t}()\n\tgo func() {\n\t\ttime.Sleep(time.Second * 3)\n\t\tk2 <- \"ses\"\n\t}()\n\tfor i := 0; i < 2; i++ {\n\t\tselect {\n\t\tcase mesaj1 := <-k1:\n\t\t\tfmt.Println(\"Mesaj 1:\", mesaj1)\n\t\tcase mesaj2 := <-k2:\n\t\t\tfmt.Println(\"Mesaj 2:\", mesaj2)\n\t\t}\n\t}\n}\n```\n\nYukarıdaki kodların bize **ses** ve **video** verisi sağlayacak bir programdan parça olduğu senaryosunu kuralım. Bu programda işlem yapabilmemiz için bize bu 2 verinin gelmesini beklememiz lazım. Verileri bekleme işlemini **select** ile yapıyoruz. Burada dikkat etmemiz gereken nokta **2** tane veri beklediğimiz için **for** atamalarında **i < 2** olarak girmeliyiz. Çünkü **i := 0** olduğu için **i 2** olana kadar arada **2** sayı var. Bu sayı boşluğu da 2 veri almayı beklememizi sağlıyor. Örnek olarak **i < 1** girip 2 veri almaya kalksak **k2**‘den gelen veriyi beklemeyecek bile. Tam tersi olarak 2 veri alacağımız halde **i < 4** girsek program **deadlock**‘a girecektir. Yani başarısız bir program olacaktır.\n" }, { "path": "boeluem-4/untitled.md", "content": "# Goroutine\n\n**Goroutine**’ler **Go Runtime** tarafından yönetilen hafif bir sistemdir. Bir işlemi eşzamanlı olarak yapmak istiyorsak, Goroutine'den faydalanabiliriz. Bu sayede aynı çalışma-zamanı içerisinde birden fazla iş parçacığı oluşturabiliriz.\n\n## Terimler\n\n### Ana iş parçacığı\n\n`Main()` fonksiyonu içerisine yazdığımız, asenkron olmayan kodlardır. Varsayılan olarak Go Runtime bu iş parçacığını izler. Programımız asenkron işlemlerin tamamlanmasını beklemiyorsa, ana iş parçacığı tamamlandığında program sona erer.\n\n### Eşzamanlılık\n\nEşzamanlılık, programlamada bir işlem gerçekleşirken, aynı zamanda başka işlemlerin de gerçekleşmesidir.\n\n## Eşzamanlı Bir İşlem Oluşturalım\n\nEşzamanlı bir işlem oluşturmak için `go` anahtar kelimesinden faydalanabiliriz. Bunun için eşzamanlı çalışacak işlemin başına `go` yazmamız yeterli olacaktır.\n\n![Asenkron İşlem Örneği](../.gitbook/assets/2020-11-09\\_23-38.png)\n\nAslında yukarıdaki örnekte `time.Sleep()` kullanarak 2 saniye bekletmemizin bir sebebi. Eğer `time.Sleep()` eklememiş olsaydık, ekrana _\"Merhaba Dünya!\"_ yazıldıktan sonra programımız sonlanacaktı. Bunun sebebi Go Runtime'ının Sadece Ana iş parçacığını beklemesi. Ana iş parçacığındaki işlemler sonlandıktan sonra, diğer işlemleri beklemiyor. Yukarıdaki örnekte bunu engellemek için `time.Sleep()` kullandık. Böylece program 2 saniye beklerken eşzamanlı işlemimiz de tamamlandı. Tabii `time.Sleep()` kullanarak beklemek mantıklı bir yöntem değil. İşlemin ne kadar süreceğini bilmediğimiz durumlar olacaktır. Bunun için Kanalları kullanabiliriz.\n" }, { "path": "boeluem-4/waitgroup-ile-goroutinein-tamamlanmasini-beklemek.md", "content": "# WaitGroup ile Asenkron İşlemleri Beklemek\n\nGoroutine’leri Asenkron programlama yaparken kullanırız. Böylece aynı anda birden fazla işlem gerçekleştirebiliriz. Peki programımızın belirttiğimiz asenkron işlemleri bekleme gibi bir ihtiyacı olsaydı, ne yapmamız gerekirdi? Bu durumlarda WaitGroup'lardan faydalanabiliriz. Örneğin projemizde 3 adet asenkron işlem bulunuyorsa, WaitGroup'a 3 değerini ekleriz. Her asenkron işlem tamamlandığında WaitGroup -1 azalır ve sıfıra geldiğinde WaitGroup tamamlanmış olur. WaitGroup'u kullanmak için ise \"sync\" paketini projemize dahil ediyoruz. Kodlar üzerinde açıklamasını görelim.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"sync\" //WaitGroup'u kullammak için\n\t\"time\" //bekleme işlemleri için\n)\n\n/*\n* waitgroup nesnesini işaretçi olarak parametre veriyoruz.\n* işaretçi olarak vermemizin sebebi, programın bekleme işlemi için\n* asıl waitgroup nesnesini kontrol etmesidir.\n */\nfunc fonksiyon1(wg *sync.WaitGroup) {\n\n\t//fonksiyonun 2 sn beklemesini istiyoruz.\n\ttime.Sleep(2 * time.Second)\n\tfmt.Println(\"Fonk1 tamamlandı\")\n\n\t//wg.Done() fonksiyonu ile waitgroup nesnesini -1 azalttık.\n\twg.Done()\n}\n\n//bu fonksiyonumuza da wg nesnesini işaretçi ile parametre olarak verdik.\nfunc fonksiyon2(wg *sync.WaitGroup) {\n\t//fonksiyonu 3 sn uyuttuk.\n\ttime.Sleep(3 * time.Second)\n\tfmt.Println(\"Fonk2 tamamlandı\")\n\n\t//-1 daha eksilttik.\n\twg.Done()\n}\n\nfunc main() {\n\t/*\n\t* Öncelikle waitgroup'u kullanabilmek için bir waitgroup\n\t* nesnesi oluşturuyoruz.\n\t */\n\tvar wg sync.WaitGroup\n\n\t/*\n\t* waitgroup'a 2 ekliyoruz. Yani 2 tane işlemden yanıt gelmesini\n\t* beklemesini istiyoruz. Aslında burada beklemeyecek. Sadece\n\t* işlem sayısını belirttik.\n\t */\n\twg.Add(2)\n\n\t/*\n\t* fonksiyon1 ve fonksiyon2'ye oluşturduğumuz wg örneğinin\n\t* bellekteki adresinin veriyoruz.\n\t */\n\tgo fonksiyon1(&wg)\n\tgo fonksiyon2(&wg)\n\tfmt.Println(\"Merhaba Dünya!\")\n\n\t/*\n\t* Burada wg.Wait() fonksiyonu ile asenkron işlemleri beklemesini\n\t* sağlıyoruz. yani waitgroup'un 0'a düşmesini bekliyoruz.\n\t* Eğer waitgroup olmadan yapsaydık. asenkron fonksiyonlarımızın tamamlanmasını\n\t* beklemeden program kendini sonlandırırdı.\n\t */\n\twg.Wait()\n\n\t//waitgroup tamamlandığında ekrana yazı bastıralım.\n\tfmt.Println(\"WaitGroup'lar tamamlandı.\")\n}\n```\n{% endcode %}\n" }, { "path": "boeluem-4/zamanlayicilar-tickers.md", "content": "# Zamanlayıcılar (Tickers)\n\nGolang’de **zamanlayıcılar**, belirli sürede bir tekrar etme işlemi için kullanılır. Zamanlayıcılar programın çalışma süresince veya durdurulana kadar çalışabilir. Örneğimizi görelim:\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"time\"\n)\nfunc main() {\n\ttekrar := time.NewTicker(500 * time.Millisecond) // her yarım saniyede 1\n\tbitti := make(chan bool)\n\tgo func() {\n\t\tfor {\n\t\t\tselect {\n\t\t\tcase <-bitti:\n\t\t\t\treturn\n\t\t\tcase zaman := <-tekrar.C:\n\t\t\t\tfmt.Println(\"Tekrar zamanı:\", zaman)\n\t\t\t}\n\t\t}\n\t}()\n\ttime.Sleep(1600 * time.Millisecond) // 1,6 saniye programı uyut\n\ttekrar.Stop() // Durdurduk\n\tbitti <- true // for döngüsünü sonlandırdık.\n\tfmt.Println(\"Tekrarlayıcı durdu!\")\n}\n```\n\nAçıklaması şöyledir:\\\n \\\n**tekrar** adında bir zamanlayıcı oluşturduk ve bu zamanlayıcının özelliği her **yarım saniyede bir** tetiklenmesi.\\\n \\\n**bitti** adında, boolean değer taşıyan bir kanal oluşturduk. Bu kanalın mantığı ileride anlayacaksınız.\\\n \\\nAnonim Goroutine fonksiyonunun içine, yani **go func()**, sınırsız döngü çeviren bir **for** oluşturduk. Bu döngünün içerisinde **select** ile kanal iletişimlerimizi dinledik. Döngümüzün sonlanması için **bitti** kanalına herhangi bir veri gelmesi gerekiyor. Aşağısındaki **case**‘de zaman değişkenimize tekrar zamanlayıcımız tetiklendikçe bu durum çalışacak. (tekrar.C ile zaman bilgisini alıyoruz.) Yani yarım saniyede bir zaman kanalına veri gelecek.\\\n \\\nAnonim Goroutine fonksiyonu, **main()** fonksiyonundan ayrı olarak çalıştığından bu fonksiyonumuzun çalışması için ona zaman aralığı vermemiz gerekiyor. **time.Sleep(1600 \\* time.Millisecond)** ile **main()** fonksiyonumuzu 1,6 saniye bekletiyoruz. Bu bekleme süresi içinde tekrar zamanlayıcımız 3 kere tetikleniyor. (500 \\* x < 1600 | x = 3) Haliyle de 3 kere ekrana çıktımızı bastırıyor. 1,6 saniye geçtikten sonra tekrar zamanlayımızı **tekrar.Stop()** ile durduruyoruz.\\\n \\\n**bitti** kanalına değer yollayarak, yukarıdaki **for** döngümüzü **return** ile sonlandırmış oluyoruz.\\\n \\\nVe en son ekranımıza **“Tekrarlayıcı durdu!”** yazımızı bastırıyoruz.\\\nÇıktımız aşağıdaki gibi olacaktır:\n\n> Tekrar zamanı: 2019-10-15 14:08:02.002909142 +0300 +03 m=+0.500235484\\\n> Tekrar zamanı: 2019-10-15 14:08:02.502993622 +0300 +03 m=+1.000319851\\\n> Tekrar zamanı: 2019-10-15 14:08:03.002952074 +0300 +03 m=+1.500278387\\\n> Tekrarlayıcı durdu!\n" }, { "path": "boeluem-5/cok-satirli-string-olusturma.md", "content": "# Çok Satırlı String Oluşturma\n\nÇok satırlı string oluşturmak için (\\`) işaretini kullanırız. Türkçe klavyeden **alt gr** ve **virgül** tuşuna basarak bu işareti koyabilirsiniz. İşte örnek kodumuz;\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n yazi := `Bu bir\n çok satırlı\n yazı örneğidir.\n`\n fmt.Printf(\"%s\", yazi)\n}\n```\n" }, { "path": "boeluem-5/disa-aktarma-exporting.md", "content": "# Dışa Aktarma (Exporting)\n\nGolang’ta dışa altarma çok basit bir olaydır. Diğer programlama dillerinde public anahtar kelimesi olarak gördüğümüz bu olayın Golang’ta nasıl yapıldığına bakalım. Golang’ta bunun için bir anahtar kelime yoktur. Dışa aktarılmasını istediğimiz öğeyi oluştururken baş harfini büyük yazarız. Örnek olarak:\n\n```go\nfunc Topla(x, y int) int {\n return x + y\n}\n```\n\nGördüğünüz gibi Topla() fonksiyonunun baş harfini büyük yazdır. Peki dışa aktarma hangi durumlarda yapılır.\n\n* Bir paket oluşturup başka bir paket içerisinden dışa aktarılan öğeyi kullanmak istiyorsak,\n* Projemiz birden fazla .go dosyası içeriyorsa ve bir sayfadaki öğeyi başka sayfada da kullanmak istiyorsak,\n\ndışa aktarma yöntemi işimizi görecektir.\\\nFonksiyonları dışa aktarabildiğimiz gibi değişkenleri ve sabitleride dışa aktarbiliriz. Örnek olarak:\n\n```go\nvar Degisken = string(\"değişken değerimiz\")\nconst Sabit = string(\"sabit değerimiz\")\n```\n\nDışa aktarma olayı Golang’ta bu kadar basittir.\n" }, { "path": "boeluem-5/format-ve-kacis-karakterleri.md", "content": "# Format ve Kaçış Karakterleri\n\n**Format Karakterleri ve Kullanım Alanları**\\\nFormat karakterleri metinsel bir ifadede (string), dizgiyi formatlandırmak için kullanılır. Yani bir metinde değişken yerleri biçimlendirmeye yarar.\n\n| Format Karakteri | Açıklama |\n| ---------------- | ------------------------------------------------ |\n| %T | Değişkenin tipini verir |\n| %t | Boolean değeri verir |\n| %d | Int (tamsayı) değeri verir |\n| %b | Sayının binary (ikili) karşılığını verir |\n| %c | Karakter değerini verir |\n| %x | Sayının hexadecimal (onaltılı) karşılığını verir |\n| %f | Float (ondalıklı) değeri verir |\n| %s | String (dizgi-metin) değeri verir |\n| %v | Değeri otomatik belirler |\n\nHemen bir örnek yapalım.\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n isim := \"Kaan\"\n yaş := 23\n kilo := 71.3\n evli := false\n\n fmt.Printf(\"İsim: %s, Yaş: %d, Kilo: %f, Evli: %t\", isim, yaş, kilo, evli)\n}\n```\n\nYukarıdaki kodlara göre şöyle bir çıktı alacaksınız:\n\n> İsim: Kaan, Yaş: 23, Kilo: 71.300000, Evli: false\n\nKilo olarak girdiğimiz değer uzun olarak görüntülendi. Bunu değiştirmek için aşağıdaki yöntem uygulanır.\n\n```go\nfmt.Printf(\"İsim: %s, Yaş: %d, Kilo: %.1f, Evli: %t\", isim, yaş, kilo, evli)\n```\n\nYukarıdaki kodda farkedeceğiniz üzere `kilo` değişkeni için olan format karakterini `%.1f` olarak değiştirdik. Bu küsüratlı sayılarda noktadan sonra 1 karakter gelebileceğini gösteriyor. Çıktımız: `71.3` olarak değişecektir.\n\n> İsim: Kaan, Yaş: 23, Kilo: 71.3, Evli: false\n\n{% hint style=\"warning\" %}\nFormat karakterleri **Printf** ve **Scanf** gibi fonksiyonlarda kullanılabilir. Bu fonksiyonların ortak özellikleri adında **f** harfi olmasıdır.\n{% endhint %}\n\n**Kaçış Karakterleri ve Kullanım Alanları**\\\nKaçış karakterleri de format karakterleri gibi metinlere etki eder. Kaçış karakterlerini kod yazma zamanında yapamadığımız işlemler için kullanırız.\n\n| Kaçış Karakteri | Açıklama |\n| --------------- | --------------------------------------- |\n| \\a | Komut satırında zil sesi çıkartır |\n| \\b | Silme tuşu görevini görür |\n| \\f | Merdiven metin yazar |\n| \\n | Yeni satıra geçer |\n| \\r | Return eder |\n| \\t | Tab tuşu gibi boşluk bırakır (4 boşluk) |\n| \\v | Dikey boşluk bırakır |\n| \\\\ | Ters-taksim yazar |\n| \\\\' | Tek tırnak yazar |\n| \\\\\" | Çift tırnak yazar |\n\nGelelim örneğimize:\n\n```go\nfmt.Print(\"Bir\\nİki\\tÜç\\\\Dört\")\n```\n\nÇıktımız şöyle olacaktır:\n\n> Bir\\\n> İki Üç\\Dört\n" }, { "path": "boeluem-5/golangte-kullanicidan-giris-alma.md", "content": "# Golang'te Kullanıcıdan Giriş Alma\n\nGolang’te diğer programlama dillerinde de olduğu gibi kullanıcıdan değer girişi alınabilir. Böylece programımızı interaktif hale getirmiş oluruz.\n\n\\\n**Scan() Fonksiyonu**\\\nBu fonksiyon boşluğa kadar olan kelimeyi kaydeder. Yeni satır boşluk olarak sayılır. Kullanımını görelim.\n\n```go\nvar yazi string\nfmt.Scan(&yazi) //yazi değişkenine değer girilmesini istedik.\nfmt.Println(“\\n”+yazi)\n```\n\nYukarıda yazdığımız kodları inceleyecek olursak, belleğe yazi isimli string türünde bir değişken kaydettik. Kullanıcının girişte bulunabilmesi için **Scan()** fonksiyonunu kullandık. Bu fonksiyonun içerisine **\\&yazi** yazdık. Bu sayede kullanıcının girdiği değer **yazi** değişkeninin içerisine kaydedilebilecek. Daha sonra **yazi** değişkenini ekrana bastırdık ve bizim yazdığımız değer görüntülendi. Scan fonksiyonunda dikkat edilmesi gereken nokta kullanıcı istediği kadar kelime girse bile programın ilk kelimeyi değer olarak alacağıdır. **Scan()** fonksiyonu boş giriş kabul etmez.\n\n**Scanf() Fonksiyonu**\\\n**Scanf()** fonksiyonu **Printf()** fonksiyonu gibi format içerir. Bu fonksiyon ile kullanıcının girişini bölüp birkaç değişkene kaydedebiliriz. Hemen kullanımını görelim.\n\n```go\nvar kelime1, kelime2 string\nfmt.Scanf(“%s %s”,&kelime1,&kelime2)\nfmt.Println(kelime1)\nfmt.Println(kelime2)\n```\n\nYukarıda yazdığımız kodları inceleyecek olursak, **kelime1** ve **kelime2** adında **string** türünde değişkenler belirledik. **Scanf()** fonksiyonu ile **Printf()**’den benzer olarak, değişkenlerin yerleştirileceği yerleri değil de, bu sefer değişkenlerin alınacağı yerleri belirtiyoruz. **%s %s** arasındaki **boşluk** sayesinden kullanıcı boşluk bırakınca girdiyi **2** değere bölebileceğiz. Hemen yanında ise içine atanacak değişkenlerimizi belirtiyoruz. Böylelikle kullanıcı giriş bölümünden Go Dili yazdığında **Go**’yu **kelime1**’in içine **Dili** de **kelime2** içine yerleştirecek. **Scanf()**, boş giriş kabul eder.\n\n**Reader ile Satır Olarak Değer Alma**\\\nAşağıdaki yöntem ile bir satır yazıyı giriş olarak alabilirsiniz.\n\n```go\ngiris := bufio.NewReader( os.Stdin)\nyazi, _ := giris.ReadString('\\n')\n```\n\n{% hint style=\"info\" %}\n**Scan** komutu ile kelime alamadığınızda **Reader** ile deneyebilirsiniz.\n{% endhint %}\n" }, { "path": "boeluem-5/import-kuetuephane-ekleme-yoentemleri.md", "content": "# Import (Kütüphane Ekleme) Yöntemleri\n\nBu yazıda sizlere Golang’ta paket import etmenin tüm yöntemlerini göstereceğim.\\\n**1. Yöntem**\n\n```go\nimport \"fmt\"\n```\n\n**fmt** paketini import ettik.\\\n**2. Yöntem**\n\n```go\nimport (\n \"fmt\"\n \"net/http\"\n)\n```\n\nBirden fazla paket import ettik\\\n**3. Yöntem**\n\n```go\nimport f \"fmt\"\n```\n\n**fmt** paketini import edip **f** olarak kullanacağımızı belirttik. Örnek olarak **fmt.Println()** yazmak yerine **f.Println()** yazacağız.\\\n**4. Yöntem**\n\n```go\nimport . \"fmt\"\n```\n\nDikkat ederseniz, **import** kelimesinden sonra **nokta** koyduk. Bu işlem sayesinde **fmt.Println()** yazmak yerine sadece **Println()** yazarak aynı işi yapmış oluruz.\\\n**5. Yöntem**\n\n```go\nimport _ \"fmt\"\n```\n\nBazen Golang yazarken kütüphaneyi ekleyip kullanmadığımız zamanlar olur. Böyle durumlarda program çalıştırılırken veya derlenirken kullandığınız editör veya ide bu bölümü silebilir. import ederken **\\_ (alt tire)** koyarak bunun üstesinden gelebiliriz.\n" }, { "path": "boeluem-5/init-fonksiyonu-oen-yuekleme.md", "content": "# init() Fonksiyonu (Ön Yükleme)\n\nGolang’te bir uygulama çalışırken genelde çalışan ilk fonksiyon **main()** fonksiyonu oluyor. Bazen programın açılışında ayarlamamız gereken ön durumlar oluşuyor. İşte **init()** fonksiyonu bize bu imkanı sunuyor. Ufak bir örnekle yazdıklarıma anlam katalım.\n\n```go\npackage main\nimport \"fmt\"\nfunc init() {\n\tfmt.Println(\"init fonksiyonu yüklendi\")\n}\nfunc main() {\n\tfmt.Println(\"main Fonksiyonu yüklendi\")\n}\n```\n\nÇıktımız aşağıdaki gibi olacaktır.\n\n> init fonksiyonu yüklendi\\\n> main Fonksiyonu yüklendi\n\nGolang’taki **init()** fonksiyonunun kullanımı, farklı dillerdeki aynı işlevi gören fonksiyonlara oranla daha kolaydır. Örnek olarak **init()** fonksiyonunda veritabanı bağlantımızı, kayıt defteri işlemlerimizi veya sadece bir kez yapmamız gereken işleri yapabiliriz. Buna imkan sağlayan mantığı aşağıdaki örnekte görelim. Bu örnekte global tanımlanmış değişkenin değerini **init()** fonksiyonunda değiştirdiğimizde **main()** gibi farklı fonksiyonlarda kullanabildiğimizi göreceğiz.\n\n```go\npackage main\nimport \"fmt\"\nvar değişken string\nfunc init() {\n\tdeğişken = \"Merhaba Dünya\"\n}\nfunc main() {\n\tfmt.Println(değişken)\n}\n```\n\nÇıktımız ise şöyle olacaktır.\n\n> Merhaba Dünya\n\nİşte **init()** fonksiyonunun böyle bir güzelliği var. Benzer bir işlevi ancak pointers (işaretçiler) ile yapabiliriz.\n\n```go\npackage main\nimport \"fmt\"\nvar değişken string = \"Naber\"\nfunc değiştir(değişken *string) {\n\t*değişken = \"Merhaba Dünya\"\n}\nfunc main() {\n\tdeğiştir(&değişken)\n\tfmt.Println(değişken)\n}\n```\n\nO da gördüğünüz gibi uzun bir işlem oluyor.\n" }, { "path": "boeluem-5/panic-and-recover.md", "content": "# Panic & Recover\n\n**Panic** ve **Recover**, Golang’de hata ayıklama için kullanılan anahtar kelimelerdir. Size bunu daha iyi ve akılda kalıcı anlatmak için teorik anlatım yerine uygulamalı öğretim yapmak istiyorum. Böylece daha akılda kalıcı olur.\\\nAşağıda **panic** durumu oluşturan bir örnek göreceğiz:\n\n```go\npackage main\nfunc main() {\n sayilar := make([]int, 5)\n sayilar[6] = 10\n}\n```\n\nYukarıda **make** fonksiyonu ile **sayilar** adında uzunluğu **5** birimden oluşan bir **int** dizi oluşturduk. Bu bildiğimiz sayısal 5 tane değişken tutan bir dizi aslında. Ama altında **sayilar** dizisinin **6**. indeksine **10** değerini atamak istedik. Fakat **sayilar** dizesinin 6. indeksi mantıken bulunmamakta. Bu haldeyken programımız **panic** hatası verecektir ve çıktımız aşağıdaki gibi olacaktır.\n\n> panic: runtime error: index out of range\\\n> goroutine 1 \\[running]:\\\n> main.main()\\\n> /home/ksc10/Desktop/deneme/main.go:5 +0x11\\\n> exit status 2\n\nİstersek biz de kritik bir bilginin nil girilmesi gibi durumlarda programı durdurabiliriz. Bunun için **panic()** fonksiyonunu kullanacağız. Hemen bir örnek yapalım.\n\n```go\npackage main\n\nimport (\n \"fmt\"\n)\n\nfunc TamIsim(Ad *string, Soyad *string) {\n if Ad == nil {\n panic(\"Ad nil olamaz\")\n }\n if Soyad == nil {\n panic(\"Soyad nil olamaz\")\n }\n fmt.Printf(\"%s %s\\n\", *Ad, *Soyad)\n fmt.Println(\"TamIsim fonksiyonu bitti\")\n}\n\nfunc main() {\n Ad := \"Yusuf\"\n TamIsim(&Ad, nil)\n fmt.Println(\"Ana fonksiyon da bitti\")\n}\n```\n\nÇıktımız burada:\n\n> panic: Soyad nil olamaz\\\n> goroutine 1 \\[running]:\\\n> main.TamIsim(0xc00007df30, 0x0)\\\n> /Users/Y/Desktop/main.go:12 +0x19a\\\n> main.main()\\\n> /Users/Y/Desktop/main.go:20 +0x65\\\n> exit status 2\n\nBurada **Soyad** değişkeni tanımsız olduğu için programımız durdu. Aynı şekilde **recover()** fonksiyonu ile **panic()** fonksiyonundan gelen veriyi alabilir, ana fonksiyonumuzun kapanmasına da engel olabiliriz. Bunun için de bir örnek yapalım.\n\n```go\npackage main\n\nimport (\n \"fmt\"\n)\n\nfunc TamIsim(Ad *string, Soyad *string) {\n if Ad == nil {\n panic(\"Ad nil olamaz\")\n }\n if Soyad == nil {\n panic(\"Soyad nil olamaz\")\n }\n fmt.Printf(\"%s %s\\n\", *Ad, *Soyad)\n fmt.Println(\"TamIsim fonksiyonu bitti\")\n}\n\nfunc main() {\n Ad := \"Yusuf\"\n defer func() {\n if r := recover(); r != nil {\n fmt.Println(\"Panik Yok : \", r)\n }\n }()\n TamIsim(&Ad, nil)\n fmt.Println(\"Ana fonksiyon da bitti\")\n}\n```\n\nÇıktımız burada :\n\n> Panik Yok : Soyad nil olamaz\n" }, { "path": "boeluem-5/print-fonksiyonu-birkac-inceleme.md", "content": "# Print Fonksiyonu Birkaç İnceleme\n\nPrint fonksiyonu Go dilinde komut satırı üzerinde yazdırma işlemi yapmak için kullanılır. Print fonksiyonunun en çok kullanılan 3 çeşidine bakalım.\n\n**Print() Fonksiyonu**\\\nBu fonksiyonun içine parametreler girerek ekrana yazdırma işlemi yapabiliriz.\n\n```go\nfmt.Print(“Merhaba Dünya!”)\n```\n\nÇıktımız şu şekilde olacaktır:\n\n> Merhaba Dünya\n\n**Println() Fonksiyonu**\\\nBu fonksiyon ile içine parametre girerek ekrana yazdırma işlemi yapabiliriz. Yazdırma işlemi yaptıktan sonra bir alt satıra geçer.\n\n```go\nfmt.Println(“satır1”)\nfmt.Println(“satır2”)\n```\n\nÇıktımız şu şekilde olacaktır;\n\n> satır1\\\n> satır2\n\n**Printf() Fonksiyonu**\\\nGelelim işimizi görecek olan Printf() fonksiyonuna. Bu fonksiyon sayesinde metinsel bölümlerin arasına değişken yerleştirebiliriz.\n\n```go\ndil:=”Go”\nyıl:=2007\nfmt.Printf(“%s dili %d yılından beri geliştiriliyor.”,dil,yıl)\n```\n\nÇıktımız şu şekilde olacaktır;\n\n> Go dili 2007 yılından beri geliştiriliyor.\n" }, { "path": "boeluem-5/sprintf.md", "content": "# Sprintf\n\nSprintf fonksiyonu fmt paketine dahil bir fonksiyondur. Bu fonksiyon değişkenlere formatlı atama yapmamıza yardımcı olur. Örneğimizi görelim:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n)\n\nfunc main() {\n\tisim := \"Kaan\"\n\n\tisimTip := fmt.Sprintf(\"isim değişkeni %T tipindedir.\", isim)\n\n\tfmt.Println(isimTip)\n}\n```\n" }, { "path": "boeluem-5/testing-test-etme.md", "content": "# Testing (Test Etme)\n\nHücrelerin vücumudaki yapı birimi olduğu gibi, aynı şekilde her bileşen de yazılımın birer parçasıdır. Yazılımın sağlıklı bir şekilde çalışabilmesi için, her bileşenin güvenilir bir şekilde çalışması gerekir.\\\nAynı şekilde vücudumuzun sağlığı hücrelerin güvenilirliği ve verimliliğine bağlı olduğu gibi, yazılımın düzgün çalışması bileşenlerin güvenilirliği ve verimliliğine bağlıdır.\\\nBiraz biyoloji dersi gibi oldu ama sonuçta aynı mantığı yürütebiliriz.\n\n**Peki bileşenler nedir?**\\\nYazılımın çalışması için yazılmış her bir kod parçasına denir. Bu bileşenlerin yazılımımızın sağlıklı bir şekilde çalıştırdığından emin olmamız gerekir.\\\nPeki bu bileşenlerin sağlamlık kontrolünü nasıl gerçekleştiririz? Tabiki **test** ederek.\\\nBir test aşamsının Golang’ta nasıl göründüğünü görelim.\n\n```go\nimport \"testing\"\nfunc TestFunc(t *testing.T){\n t.error() //testin başarısız olduğunu bildirir.\n}\n```\n\nYukarıdaki işlem Golang’ta yapılan bir birim testin temel yapısıdır. Yerleşik **testing** paketi, Golang’ın standart paketleri içerisinde gelir. Birim testi, **\\*testing.T** türündeki elemanı kabul eden ve bu elemanı göre hata yayınlayan bir bir işlemdir.\\\nBu fonksiyonların adı büyük harfle başlamalı ve birleşik olan adın devamı da büyük harfle başlamalıdır. Yani **camel-case** olmalıdır.\\\n`TestFunc olmalıdır ve Testfunc olmamalıdır.`\\\nUygulama örneğimize geçelim.\\\nBir proje klasörü oluşturalım ve **main.go** dosyamız şöyle olsun.\n\n```go\npackage main\nimport \"fmt\"\nfunc Merhaba(isim string) (çıktı string) {\n çıktı = \"Merhaba \" + isim\n return\n}\nfunc main() {\n selamla := Merhaba(\"Kaan\")\n fmt.Println(selamla)\n}\n```\n\n**main.go** dosyamızda fonksiyona adını girdiğimiz kişiyi selamlıyor. Buraya kadar gayet basit bir program. Fonksiyonlarımızı test edeceğimiz için baş harflerini büyük yazmayı unutmuyoruz. Böylelikle fonksiyonlarımızı dışarı aktarabiliriz. Test fonksiyonumuzun çalışma mantığını görmek için **main\\_test.go** dosyamıza bakalım.\n\n```go\npackage main\nimport \"testing\"\nfunc TestMerhaba(t *testing.T) {\n if Merhaba(\"Kaan\") != \"Merhaba Kaan\" {\n t.Error(\"Merhaba Fonksiyonunda bir sıkıntı var!\")\n }\n}\n```\n\nYukarıda ise **main.go** sayfamızdaki **Merhaba** fonksiyonunu test etmek için **TestMerhaba** adında fonksiyon oluşturduk. **t \\*testing.T** ibaresi ile bu işlemin test etmeye yönelik bir işlem olduğunu belirttik.\\\nFonksiyonun içerisine baktığımızda, **Merhaba(“Kaan”)** işleminin sonucu **“Merhaba Kaan”** olmadığı zaman test hatası vermesini istedik. Ve gözükecek hatayı belirttik.\\\nTest işlemi yapmak için aşağıdaki komutları komut satırına yazıyoruz.\n\n> go test\n\nYukarıdaki yazdığımız kodlara göre şöyle bir çıktımızın olması gerekir.\n\n> PASS ok\\\n> \\_/home/ksc10/Desktop/deneme 0.002s\n\nEğer **TestMerhaba** fonksiyonunda test koşuluna **“Merhaba Kaan”** yerine **“Merhaba Ahmet”** yazsaydık, aşağıdaki gibi bir **go test** çıktımız olurdu.\n\n> \\--- FAIL: TestMerhaba (0.00s)\\\n> main\\_test.go:7: Merhaba Fonksiyonunda bir sıkıntı var!\\\n> FAIL\\\n> exit status 1\\\n> FAIL \\_/home/ksc10/Desktop/deneme 0.002s\n\n**Go Test Komutları**\n\n| Komut | Açıklama |\n| ------------------------ | ----------------------------------------------------------------- |\n| go test | İçerisinde bulunduğu projenin tüm test fonksiyonlarını test eder. |\n| go test -v | Her test için ayrı bilgi verir. |\n| go test -timeout 30s | 30 saniye zaman aşımı ile test eder. |\n| go test -run TestMerhaba | Sadece belirli bir fonksiyonu test eder. |\n\n**Örnek kullanımı:**\\\n**main\\_test.go** dosyamızdaki **TestMerhaba** fonksiyonumuzu **10 saniye** zaman aşımı ile test edecek komut\n\n> go test -timeout 30s -run TestMerhaba\n\nBu yazımızda Golang’de test işleminin nasıl yapıldığını gördük. Mantığını daha iyi kavramak için bir proje üzerinde gerekli olduğu yerde kullanmamız gerekir.\n" }, { "path": "boeluem-6-paketler/komut-satiri-arguemanlari-args.md", "content": "# Komut Satırı Argümanları (Args)\n\nGolang ile programlarımızın komut satırı üzerinden argümanlar ile çalışmasını sağlayabiliriz. İşte paketimiz:\n\n```\nimport \"os\"\n```\n\n`os` paketimizdeki `Args` fonksiyonu bize string dizi sunar. **** Bir örnek görelim.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n)\n\nfunc main() {\n\tfor i, arg := range os.Args {\n\t\tfmt.Println(i, \"=\", arg)\n\t}\n}\n```\n\n`for-range` ile `os.Args`'ın uzunluğu kadar işlem yapıyoruz ve içerisindekileri indeksi ile ekrana bastırıyoruz. Şöyle bir çıktımız oluyor:\n\n> ./main naber nasılsın\n>\n> 0 = ./main\\\n> 1 = naber\\\n> 2 = nasılsın\n" }, { "path": "boeluem-6-paketler/komut-satiri-bayraklari-flags.md", "content": "# Komut Satırı Bayrakları (Flags)\n\nKomut satırı bayrakları, örnek olarak;\n\n> ./uygulamamız -h\n\nSondaki `-h` bir flag(bayrak)’dir. Örnek bir program yazalım.\n\n```go\npackage main\nimport (\n\t\"flag\"\n\t\"fmt\"\n)\nfunc main() {\n\tkelime := flag.String(\"kelime\", \"varsayılan kelime\", \"metin tipinde\")\n\tsayi := flag.Int(\"sayi\", 1881, \"sayı tipinde\")\n\tmantiksal := flag.Bool(\"mantiksal\", false, \"boolean tipinde\")\n\tflag.Parse()\n\tfmt.Println(\"kelime:\", *kelime)\n\tfmt.Println(\"sayi:\", *sayi)\n\tfmt.Println(\"mantiksal:\", *mantiksal)\n}\n```\n\nGelelim açıklamasına;\\\n**kelime** isminde **string** tipinde bir flag oluşturduk. **flag.String()** fonksiyonu içerisinde 1. parametre komut satırından **“-kelime”** argümanıyla gireceğimizi gösteriyor. Varsayılan değeri **“varsayılan kelime”** olacak ve açıklama bölümünde **“metin tipinde”** yazacak.\\\n**sayi** isminde **int** tipinde bir flag oluşturduk. **flag.Int()** fonksiyonu içerisinde komut satırından **“-sayi”** argümanıyla gireceğimizi belirttik. Varsayılan değeri **1881** olacak ve açıklama bölümünde **“sayı tipinde”** yazacak.\\\n**mantiksal** isminde **bool** tipinde bir flag oluşturduk. **flag.Bool()** fonksiyonunda **“-mantiksal”** argumanıyla çağırılacağını belirttik. Varsayılan değeri **false** olacak ve açıklama bölümünde **“boolean tipinde”** yazacak.\\\nUygulamamızı build edelim ve ismi **uygulama** olsun.\n\n> go build -o ./uygulama .\n\nWindows için build ediyorsanız, `./uygulama` yerine `./uygulama.exe` yazarak build edin. (Hatırlatma yapayım dedim) Build ettikten sonra örnek bir kullanımını yapalım.\n\n> ./uygulama -kelime=Atatürk -sayi=1881 -mantiksal=true\n\nÇıktımız şu şekilde olacaktır.\n\n> kelime: Atatürk\\\n> sayi: 1881\\\n> mantiksal: true\n\nPeki bu girdiğimiz flag açıklamaları ne oluyor diye soracak olursanız eğer, onu da aşağıdaki komutu yazarak görebilirsiniz.\n\n> ./uygulama -h\n\nÇıktımız şu şekilde olacaktır.\n\n> Usage of ./uygulama:\\\n> \\-kelime string\\\n> metin tipinde (default \"varsayılan kelime\")\\\n> \\-mantiksal\\\n> boolean tipinde (default false\")\\\n> \\-sayi int\\\n> sayı tipinde (default 1881)\n" }, { "path": "boeluem-6-paketler/log-kayit.md", "content": "# Log (Kayıt)\n\n**Log** paketi standart Golang paketleri içerisinde gelir ve programdaki olayları kaydetmemizi yarayacak bir altyapı sunar. Log programcının gözü kulağıdır. Bize hataları (bugs) bulmamız için kolaylık sağlar. Örneğimize geçelim.\n\n```go\npackage main\nimport (\n \"log\" \n)\nfunc init(){\n log.SetPrefix(\"KAYIT: \")\n log.SetFlags(log.Ldate | log.Lmicroseconds | log.Llongfile)\n}\nfunc main() {\n log.Println(\"main fonksiyonu başladı\")\n \n log.Fatalln(\"ölümcül hata\")\n \n log.Panicln(\"panic mesajı\")\n}\n```\n\nHemen açıklamasına geçelim. İlk olarak `log` paketimizi içe aktarıyoruz. **** `init()` fonksiyonunda log paketimiz ile ilgili ön ayarları yapıyoruz. Tabi biz bu işlemleri `init` fonksiyonu içerisinde yapmak zorunda değiliz.\n\n{% content-ref url=\"../boeluem-5/init-fonksiyonu-oen-yuekleme.md\" %}\n[init-fonksiyonu-oen-yuekleme.md](../boeluem-5/init-fonksiyonu-oen-yuekleme.md)\n{% endcontent-ref %}\n\n`init()` fonksiyonumuzun içerisini dikkatlice inceleyelim. log paketimizin üzerine ayarlamalar yapıyoruz.\\\n\n\n`SetPrefix()` fonksiyonu ile log çıktımızın satırının başında ne yazacağını belirleyebiliyoruz.\\\n\n\n`SetFlags ()` fonksiyonu ile log çıktımızın görünüşünü ayarlıyoruz. **log.Ldate** bize zamanını gösteriyor. `log.Lmicroseconds` mikrosaniyeyi ve `log.Llongfile` ise dosyanın bulunduğu dizin ile ismini ve yapılan işlem ile ilgili satırı gösteriyor.\\\n\n\nlog önyüklemizi yaptığımızı opsiyonel olarak **log.Println()** ile belirtiyoruz.\\\n\n\n**`main()`** fonksiyonumuzun içerisini incelediğimizde ise;\\\n`log.Println()` fonksiyonu ile klasik log çıktılama işlemini yapıyoruz. Fonksiyonun sonundaki **ln** bir alt satıra geçildğini gösteriyor.\\\n\n\n`log.Fatalln()` fonksiyonu ile kritik hataları bildirir. `log.Println()` fonksiyonundan farkı program **1 çıkış kodu** ile biter. Bu da programın hatalı bittiği anlamına gelir. Normalde sağlıklı çalışan bir program **0 çıkış kodu** ile biter. 0 çıkış kodunu Golang programlama da kullanmamıza gerek kalmaz. Fakat C gibi dillerde ana fonksiyonun sonunda **return 0** ibaresini yazmak zorundayız.\\\n`log.Panicln()` fonksiyonunda ise ekrana çıktımızı verir ve aynı zamanda bunu normal **panic()** fonksiyonu ile yapar.\n\n\\\nÇıktımız ise şöyle olacaktır:\n\n> KAYIT: 2019/10/10 20:29:14.107529 /home/ksc10/Desktop/deneme/main.go:13: main fonksiyonu başladı\\\n> KAYIT: 2019/10/10 20:29:14.107539 /home/ksc10/Desktop/deneme/main.go:15: ölümcül hata\\\n> exit status 1\n\nGördüğünüz gibi son satırda **çıkış durumunun 1** olduğunu yazıyor.\\\npanic mesajı programı direkt sonlandırır. panic mesajını daha üste yazarak deneyebilirsiniz.\n\nDiğer bir örneğimize geçelim.\n\n```go\npackage main\n\nimport (\n\t\"log\"\n\t\"os\"\n)\n\nfunc main() {\n\tlog.SetPrefix(\"KAYITIM: \")\n\tlog.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)\n\tlogDosyam, _ := os.Create(\"kayit.log\")\n\tdefer logDosyam.Close()\n\tlog.SetOutput(logDosyam)\n\tlog.Println(\"Bir sıkıntı yaşadık ama mühim değil :/\")\n\tlog.Fatalln(\"Bu sefer çok kötü birşey oldu :<\")\n}\n```\n\nYukarıdaki kodlarımızda 9. satırda logumuz için ön yazı ekledik. Daha sonra logumuzun şeklini yapılandırdık. Bu sefer `log.Lshortfile` yazarak dosyamızın ismini dizin olmadan ve çıktının yapıldığı satırı bastırmasını istedik.\n\n11\\. satırda loglarımızı kaydetmek için `kayit.log` adında bir dosya oluşturduk. `log.SetOutput` fonksiyonu ile log dosyamızı belirttik. Artık loglarımız komut satırında gözükmek yerine belirttiğimiz dosyaya yazılacaktır.\n\n`kayit.log` dosyamızda aşağıdaki gibi bir sonuç ile karşılaşacağız.\n\n> KAYITIM: 2022/04/18 02:44:56 main.go:14: Bir sıkıntı yaşadık ama mühim değil :/\n>\n> KAYITIM: 2022/04/18 02:44:56 main.go:15: Bu sefer çok kötü birşey oldu :<\n\nYukarıdaki senaryoda log çıktılarımız `kayit.log` dosyasına yazıldı. Programı çalıştırdığınızda farketmişsinizdir, log çıktılarımız komut satırı üzerinde görüntülenmedi. Çünkü kodumuzda belirttiğimiz gibi bir dosyaya yazılması için ayarlama yaptık. Peki log çıktımızın hem belirttiğimiz dosyaya yazılmasını hem de komut satırına bastırılmasını isteseydeik ne yapmamız gerekirdir? Bir sonraki örneğimize geçelim.\n\n```go\npackage main\n\nimport (\n\t\"io\"\n\t\"log\"\n\t\"os\"\n)\n\nfunc main() {\n\tlog.SetPrefix(\"KAYITIM: \")\n\tlog.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)\n\tlogDosyam, _ := os.Create(\"kayit.log\")\n\tdefer logDosyam.Close()\n\n\tmw := io.MultiWriter(os.Stdout, logDosyam)\n\n\tlog.SetOutput(mw)\n\tlog.Println(\"Bir sıkıntı yaşadık ama mühim değil :/\")\n\tlog.Fatalln(\"Bu sefer çok kötü birşey oldu :<\")\n}\n```\n\nÖnceki kodlarımızdan farklı olarak 15. satırda bir `multiwriter` oluşturduk ve hem komut satırına hem log dosyamıza yazdırması için ayarladık.\n\n`setOutput` fonksiyonunda ise multiwriter'ımızı kullandık. Bu sayede programımız çalıştığında log çıktılarımız hem komut satırında hem de `kayit.log` dosyamıza yazdırılacaktır.\n" }, { "path": "boeluem-6-paketler/os-exec-komut-satirina-erisim.md", "content": "# os/exec (Komut Satırına Erişim)\n\n**os/exec** paketi komut satırına (cmd, powershell, terminal) komut göndermemizi sağlayan Golang ile bütünleşik gelen bir pakettir. Bu paket sayesinde oluşturacağımız programa sistem işlerini yaptırabiliriz. Örnek olarak dosya/klasör taşıma/silme/oluşturma/kopyalama gibi işlemleri yaptırabilir. Daha doğrusu komut satırı/terminal üzerinden yapabildiğimiz her işlemi yaptırabiliriz. Tabi kullandığımız işletim sistemine göre terminal komutları değiştiği için ona göre örnek vermeye çalışacağım.\n\n\\\n**Örnek 1: Komut Satırına Komut Gönderme**\\\nUfak bir örnek ile başlayalım.\n\n```go\npackage main\nimport (\n \"os\"\n \"os/exec\"\n)\nfunc main() {\n cmd := exec.Command(\"mkdir\", \"klasörüm\")\n cmd.Stdout = os.Stdout\n cmd.Run()\n}\n```\n\n**“mkdir klasörüm”** komutu programın çalıştırıldığı dizinde **“klasörüm”** adında bir klasör oluşturur. Komut girerken dikkat etmeniz geren çok önemi bir detay var. Yazacağınız komut birden fazla kelimeden oluşuyorsa mutlaka ayrı ayrı girmelisiniz. Eğer **exec.Command()** fonksiyonuna direkt olarak **“mkdir klasörüm”** olarak girseydik, komutu tek kelime olarak algılayacaktı. Yani **string dizisi** mantığında çalışıyor bu olay. Sonuç olarak yukarıdaki gibi basit bir şekilde komut satırına komut yollayabilirsiniz.\\\n**Örnek 2: Komut Satırına Komut Gönderip Çıktısını Okuma**\\\nYukarıda çok kolay bir şekilde komut göndermeyi gördük. Fakat iş komutun çıktısını okumaya gelince işler biraz karışıyor. Yavaştan vaziyetinizi alın ![Wink](https://i1.wp.com/golangtr.org/forum/images/smilies/wink.png?w=770)\\\nAslında korkulacak bir olay yok. Yeter ki mantığını anlayalım. Şimdi yapacağımız işlemleri 4 ana parçaya bölelim.\n\n1. Komutun tanımlanması\n2. Çıktı okuyucusunun tanımlanması\n3. Komutun başlatılması\n4. Komutun çalışması\n\nHemen kodlarımıza geçelim.\n\n```go\npackage main\nimport (\n \"bufio\"\n \"fmt\"\n \"os\"\n \"os/exec\"\n)\nfunc main() {\n //komutun tanımlanması\n cmd := exec.Command(\"go\", \"version\")\n cmdOkuyucu, hata := cmd.StdoutPipe()\n if hata != nil {\n fmt.Fprintln(os.Stderr, \"Çıktı okunurken hata oluştu:\", hata)\n os.Exit(1)\n }\n //çıktı okuyucusunun tanımlanması\n çıktı := bufio.NewScanner(cmdOkuyucu)\n go func() {\n for çıktı.Scan() {\n fmt.Println(çıktı.Text())\n }\n }()\n //komutun başlatılması\n hata = cmd.Start()\n if hata != nil {\n fmt.Fprintln(os.Stderr, \"Komut başlatılamadı:\", hata)\n os.Exit(1)\n }\n //komutun çalışması\n hata = cmd.Wait()\n if hata != nil {\n fmt.Fprintln(os.Stderr, \"Komut çalışırken hata oluştu:\", hata)\n os.Exit(1)\n }\n}\n```\n\nGelelim yukarıdaki kodların açıklamasına…\\\n**cmd** adında bir değişken oluşturduk. Bu değişkenimiz sayesinde **exec.Command()** fonksiyonuyla komutlarımızı girdik.\\\n**cmd.StdoutPipe()** fonksiyonuyla gönderdiğimiz komutun çıktılarını alabiliyoruz. **cmdOkuyucu** değişkenine komut çıktımızı aldık. **hata** değişkenimize ise komut girildiğinde oluşan hata mesajını aldık.\\\n**hata** değişkeninin içi boş değilse ekrana bastırmasını ve **1** numaralı çıkış kodunu vermesini istedik. Bu arada 1 numaralı çıkış kodu hatalar için kullanılır. Golang programlarında görmüyoruz ama **0** numaralı çıkış kod da işler yolunda gittiği zaman kullanılır. C dili kodlayan arkadaşlarımız bilir, **int main** fonksiyonunun sonuna **return 0** ibaresi girilir. Buraya kadar olan işlemlerimiz komutun tanımlanması ile ilgiliydi.\\\nÇıktımızı okuyabilmemiz için birkaç işlem yapmamız gerekiyor. Ne yazık ki çıktımızı direkt olarak değişkene atayıp ekrana bastıramıyoruz. **çıktı** adında değişkenimizi oluşturuyoruz. Bu değişkenimiz **cmdOkuyucu** değişkenini taramaya yarayacak. Hemen aşağısında goroutine fonksiyonumuzda **çıktı.Scan()** döngüsü ile çıktı sonucumuzu ekrana bastırıyoruz.\\\nBuraya kadar tanımlamalarımız yapmış bulunduk. Bundan sonra işlemlerimiz komutumuzun çalıştırılması ve sonucun beklenmesi olacak.\\\n**hata** değişkenimize **cmd.Start()** fonksiyonunu atayarak komut başlatma işleminde hata oluşursa veriyi çekmesini sağladık. Hata var ise **error** tipindeki hata mesajımızı ekrana ve 1 numaralı hatayı ekrana bastıracak.\\\nSon işlemimiz ise komutun sonuçlanmasının beklenmesi. **hata** değişkenimize **cmd.Wait()** fonksiyonunu ekleyerek bekleme işleminde oluşabilecek hatanın mesajını çekmiş olduk. Aşağısında eğer hata var ise ekrana bastırması için gerekli kodlarımızı girdik. Son olarak **1** numaralı çıkış işlemini yaptık.\\\nGördüğünüz gibi çıktı alma işlemi biraz daha uzun. Ama mantığını anladıktan sonra kolay bir işlem olduğunu düşüyorum.\\\n**Örnek 3: Hata Detayı Çekmeden Komut Çıktısı Alma**\\\nEğer ben hata çıktısının detayını almak istemiyorum, benim işim sadece çıktıyla diyorsanız yapacağımız işlemler gerçekten kolaylaşıyor. Hemen kodlarımızı görelim.\n\n```go\npackage main\nimport (\n \"fmt\"\n \"log\"\n \"os/exec\"\n)\nfunc main() {\n cmd := exec.Command(\"go\", \"versison\")\n çıktı, hata := cmd.CombinedOutput()\n if hata != nil {\n log.Fatalf(\"Komut hatası: %s\\n\", hata)\n }\n fmt.Printf(string(çıktı))\n}\n```\n\nKodlarımızın açıklamasına geçelim. **cmd** adında değişkenimizde **exec.Command()** fonksiyonu ile komutlarımızı tanımladık. **çıktı** ve **hata** değişkenimize komut çıktılarımızı aldık. Burada **hata** değişkeni sadece hata numarasını verecektir. Detayları barındırmaz. Eğer hatamız var ise ekrana bastırmasını istedik. Aşağısında ise **çıktı** değişkenimiz **byte dizisi** tipinde olduğu için **string**‘e çevirip ekrana bastırdık.\n" }, { "path": "boeluem-6-paketler/os-signal.md", "content": "---\ndescription: https://golang.org/pkg/os/signal/ sayfasından çeviridir.\n---\n\n# os/signal\n\n**os/signal** paketi gelen sinyallere erişim sağlar. Genellikle Unix-benzeri sistemlerde kullanılır. **Windows** ve **Plan9**'da kullanımı farklıdır.\n\n## Sinyal Türleri\n\n**SIGKILL** ve **SIGSTOP** sinyalleri bir program tarafından yakalanmayabilir ve bu nedenle bu paketten etkilenemez.\n\nSenkron sinyaller, program yürütmedeki hatalarla tetiklenen sinyallerdir: **SIGBUS**, **SIGFPE** ve **SIGSEGV**. Bunlar, `os.Process.Kill` veya **kill** programı veya benzer bir mekanizma kullanılarak gönderildiklerinde değil, yalnızca program yürütülmesinden kaynaklandığında eşzamanlı olarak kabul edilir. Genel olarak, aşağıda tartışılanlar dışında, Go programları eşzamanlı bir sinyali çalışma zamanı paniğine dönüştürecektir.\n\nKalan sinyaller asenkron sinyallerdir. Program hataları tarafından tetiklenmezler, bunun yerine çekirdekten veya başka bir programdan gönderilirler.\n\nAsenkron sinyallerden, **SIGHUP** sinyali, bir program kontrol terminalini kaybettiğinde gönderilir. **SIGINT** sinyali, kontrol terminalindeki kullanıcı, varsayılan olarak ^ C (Kontrol-C) olan kesme karakterine bastığında gönderilir. **SIGQUIT** sinyali, kontrol terminalindeki kullanıcı varsayılan olarak ^ (Kontrol-Ters Taksim) olan çıkış karakterine bastığında gönderilir. Genel olarak, bir programın ^ C'ye basarak çıkmasına neden olabilir ve ^ tuşuna basarak bir yığın dökümü ile çıkmasına neden olabilirsiniz.\n\n## Go Programlarında Sinyallerin Varsayılan Davranışı\n\nVarsayılan olarak, senkronize bir sinyal çalışma zamanı paniğine dönüştürülür. **SIGHUP**, **SIGINT** veya **SIGTERM** sinyali programın çıkmasına neden olur. **SIGQUIT**, **SIGILL**, **SIGTRAP**, **SIGABRT**, **SIGSTKFLT**, **SIGEMT** veya **SIGSYS** sinyali, programın yığın dökümü ile çıkmasına neden olur. Bir **SIGTSTP**, **SIGTTIN** veya **SIGTTOU** sinyali sistem varsayılan davranışını alır (bu sinyaller kabuk tarafından iş kontrolü için kullanılır). **SIGPROF** sinyali, `runtime.CPUProfile`'ı uygulamak için doğrudan Go çalışma zamanı tarafından işlenir. Diğer sinyaller yakalanacak ancak herhangi bir işlem yapılmayacaktır.\n\nGo programı, **SIGHUP** veya **SIGINT** göz ardı edilerek başlatılırsa (sinyal işleyici **SIG\\_IGN**'a ayarlı), bunlar ihmal edilmiş olarak kalacaktır.\n\nGo programı boş olmayan bir sinyal maskesi ile başlatılırsa, bu genellikle kabul edilir. Bununla birlikte, bazı sinyaller açıkça engellenmiştir: eşzamanlı sinyaller, **SIGILL**, **SIGTRAP**, **SIGSTKFLT**, **SIGCHLD**, **SIGPROF** ve **GNU/Linux**'ta **32 (SIGCANCEL)** ve **33 (SIGSETXID)** **(SIGCANCEL ve SIGSETXID)** sinyalleri **glibc** tarafından dahili olarak kullanılır. `Os.Exec` veya `os/exec` paketi tarafından başlatılan alt işlemler, değiştirilmiş sinyal maskesini miras alır.\n\n## Go Programlarında Sinyallerin Davranışını Değiştirme\n\nBu paketteki işlevler, bir programın Go programlarının sinyalleri işleme şeklini değiştirmesine izin verir.\n\n**Notify**, belirli bir eşzamansız sinyal kümesi için varsayılan davranışı devre dışı bırakır ve bunun yerine bunları bir veya daha fazla kayıtlı kanal üzerinden iletir. Özellikle, **SIGHUP**, **SIGINT**, **SIGQUIT**, **SIGABRT** ve **SIGTERM** sinyalleri için geçerlidir. Bu aynı zamanda iş kontrol sinyalleri **SIGTSTP**, **SIGTTIN** ve **SIGTTOU** için de geçerlidir ve bu durumda sistem varsayılan davranışı oluşmaz. Aynı zamanda, başka şekilde hiçbir eyleme neden olmayan bazı sinyaller için de geçerlidir: **SIGUSR1**, **SIGUSR2**, **SIGPIPE**, **SIGALRM**, **SIGCHLD**, **SIGCONT**, **SIGURG**, **SIGXCPU**, **SIGXFSZ**, **SIGVTALRM**, **SIGWINCH**, **SIGIO**, **SIGPWR**, **SIGSIGTHEZW**, **SIGTHAW**, **SIGLOST**, **SIGXRES**, **SIGJVM1**, **SIGJVM2** ve sistemde kullanılan gerçek zamanlı sinyaller. Bu sinyallerin tümünün tüm sistemlerde mevcut olmadığını unutmayın.\n\nProgram **SIGHUP** veya **SIGINT** göz ardı edilerek başlatılmışsa ve her iki sinyal için de **Notify** çağrılırsa, bu sinyal için bir sinyal işleyici kurulacak ve artık göz ardı edilmeyecektir. Daha sonra bu sinyal için **Reset** veya **Ignore** çağrılırsa veya o sinyal için **Notify**'ye iletilen tüm kanallarda **Stop** çağrılırsa, sinyal bir kez daha yok sayılır. **Reset**, sinyal için sistemin varsayılan davranışını geri yüklerken, **Ignore**, sistemin sinyali tamamen yok saymasına neden olur.\n\nProgram boş olmayan bir sinyal maskesi ile başlatılırsa, bazı sinyallerin blokajı yukarıda açıklandığı gibi açıkça kaldırılacaktır. Engellenen bir sinyal için **Notify** çağrılırsa, engellemesi kaldırılır. Daha sonra bu sinyal için **Reset** çağrılırsa veya bu sinyal için **Notify**'ye iletilen tüm kanallarda **Stop** çağrılırsa, sinyal bir kez daha engellenecektir.\n\n## Windows\n\nWindows'ta a ^ C (Control-C) veya ^ BREAK (Control-Break) normalde programın çıkmasına neden olur. `Os.Interrupt` için **Notify** çağrılırsa, ^ C veya ^ BREAK `os.Interrupt`'ın kanala gönderilmesine neden olur ve program çıkmaz. **Notify**'ye geçen tüm kanallarda **Reset** çağrılırsa veya **Stop** çağrılırsa, varsayılan davranış geri yüklenir.\n\n## Plan9\n\nPlan 9'da, sinyaller bir dizge olan `syscall.Note` türüne sahiptir. **Notify** ile bir sistem çağrısı çağırmak, bu dize bir not olarak gönderildiğinde bu değerin kanala gönderilmesine neden olur.\n\n## Örnek Uygulama\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"os/signal\"\n\t\"time\"\n)\n\nfunc main() {\n\t//os.Signal tipinde değer taşıyan bir kanal oluşturduk\n\tsignalKanalı := make(chan os.Signal, 1)\n\n\t/*\n\t* Ana iş parçacığı sonlanmaması için bir kanal\n\t* oluşturalım.\n\t */\n\tprogramBitti := make(chan bool)\n\n\t/*\n\t* os.Interrupt sinyali ile programramın sonlanması\n\t* yerine sinyali signalKanalı'na yönlendirelim.\n\t */\n\tsignal.Notify(signalKanalı, os.Interrupt)\n\n\t/*\n\t* asenkron olarak signalKanalı'nı dinleyelim. Sinyal\n\t* geldiğinde yani CTRL + C'ye basıldığında for döngüsü\n\t* içerisindeki kodlar çalışacak.\n\t */\n\tgo func() {\n\t\tfor range signalKanalı {\n\t\t\tfmt.Println(\"Kontrol + C 'ye basıldı\")\n\n\t\t\t//5 sn bekleyelim.\n\t\t\ttime.Sleep(time.Second * 5)\n\n\t\t\t/*\n\t\t\t* Burada bekleyerek size programın CTRL + C'ye\n\t\t\t* basıldığında kapanmadığını gösteriyorum :)\n\t\t\t */\n\t\t\tfmt.Println(\"bitti\")\n\n\t\t\t/*\n\t\t\t* Kanala değer göndererek ana iş parçacığındaki\n\t\t\t* programBitti kanalının bekleyişine son verelim.\n\t\t\t */\n\t\t\tprogramBitti <- true\n\t\t}\n\n\t}()\n\n\t//Ana iş parçacığı sonlanmasın diye kanalı bekleyelim\n\t<-programBitti\n}\n\n```\n{% endcode %}\n\n## Örnek: Tüm Sinyalleri Yakalamak\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"os/signal\"\n)\n\nfunc main() {\n\t//Sinyallerin gönderileceği kanalı oluşturalım.\n\tkanal1 := make(chan os.Signal, 1)\n\n\t//Gelen sinyalleri kanal1'e yönlendirelim\n\tsignal.Notify(kanal1)\n\n\t// kanal1'e sinyal gelene kadar programı bekletelim.\n\tsinyalTürü := <-kanal1\n\tfmt.Println(\"Sinyal Türü:\", sinyalTürü)\n}\n```\n\n" }, { "path": "boeluem-6-paketler/paket-kuetuephane-yazmak.md", "content": "# Paket (Kütüphane) Yazmak\n\nBu bölümde Go üzerinde nasıl kendi paketimizi (kütüphanemizi) oluşturacağımıza bakacağız.\n\n### Bir Paketin Özellikleri\n\n* İçerisinde `.go` dosyaları bulunan bir klasördür.\n* Diğer projeler tarafından içe aktarılabilir.\n* Dışa aktarılabilen veya aktarılamayan veriler içerir.\n* Açık kaynaktır.\n* `main()` fonksiyonu içermez.\n* `package main` değildir.\n\nPaket oluştururken dikkat etmemiz gereken prensipler vardır. Bunlar şık ve basit kod yazımı, dışarıdan kullanımı basit, mümkün olduğunca diğer paketlere bağımsız olmasıdır. Bu prensiplere dikkat ederek daha iyi bir paket yazabilirsiniz.\n\n### Proje Klasöründe Yerel Kütüphane Oluşturma\n\nÖncelikle aşağıdaki gibi bir dosya düzenimiz olduğunu varsayalım.\n\n![Proje Klasörümüzün Yapısı](../.gitbook/assets/package.png)\n\nYukarıdaki gibi `paketim` klasörü içerisinde `paketim.go` dosyamız olsun.\n\n`paketim.go` dosyamızın içi aşağıdaki gibi olsun.\n\n```go\npackage paketim\n\nimport \"fmt\"\n\nfunc Yaz() {\n\tfmt.Println(\"yazdım!\")\n}\n```\n\n`package paketim` ile paketimizin ismini belirledik. Bu isim paket klasörümüz ile aynı olmalıdır. Daha sonra projemizde kullanabilmemiz için dışa aktarılmış şekilde `Yaz()` fonksiyonu oluşturduk. Bu fonksiyonun ne işe yaradığı zaten belli.\n\n`main.go` dosyamız ise aşağıdaki gibi olsun.\n\n```go\npackage main\n\nimport p \"./paketim\"\n\nfunc main() {\n\tp.Yaz()\n}\n```\n\n`import p \"./paketim\"` yazarak özel paketimizin yerel konumunu belirterek, `p` lakabı (alias) ile çağırdık.\n\n`Yaz()` fonksiyonumuzu ise `p.Yaz()` şeklinde kullandık.\n\n### Git Sisteminde Kütüphane Paylaşımı\n\nOluşturduğumuz kütüphaneyi Github, Gitlab, Bitbucket vb. sitelerde barındırarak diğer geliştiricilerinde kütüphanelerinizden faydalanmasını sağlayabilirsiniz.\n\nBunun için kütüphanenizin isminde bir repo oluşturup, içerisinde Go dosyalarınızı yükleyin. Daha sonra `go get github.com/id/repoismi` şeklinde projenize import edebilirsiniz.\n" }, { "path": "boeluem-6-paketler/regexp-kuralli-ifadeler.md", "content": "# Regexp (Kurallı İfadeler)\n\n**Regular Expressions (Regexp)**, modern programlama dillerinin neredeyse hepsinde bulunan metinsel ifadelerinizin yapısını kontrol etmenizi sağlayan bir pakettir.\n\nBu paket sayesinde yazdığımız programda ifadelerin uygunluğunu kontrol edebilir, işimize yarayacak ifade/ifadeleri daha kolay ayırabilir ve giriş yapılan ifadeleri uygun bir düzene koyabiliriz.\n\nÖrneğimizi görelim\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"regexp\"\n)\n\nfunc main() {\n\tvar isimKontrol = regexp.MustCompile(`^[a-z]+[0-9]$`)\n\n\tfmt.Println(isimKontrol.MatchString(\"kaan10\")) //false\n\tfmt.Println(isimKontrol.MatchString(\"emir6\")) //true\n\tfmt.Println(isimKontrol.MatchString(\"gokhan\")) //false\n\tfmt.Println(isimKontrol.MatchString(\"Altan2\")) //false\n\tfmt.Println(isimKontrol.MatchString(\"8erkay\")) //false\n}\n```\n\nÖncelikle yukarıdaki işlemleri yapabilmemiz için, projemizde `\"regexp\"` paketini çağırmamız gerekiyor.\n\n`isimKontrol` adında bir değişken oluşturduk ve bu değişkenimizde `MustCompile()` fonksiyonu ile metinsel ifademizin kurallarını belirledik.\n\nBelirlediğimiz kural ise dizgimizin küçük harflerle a'dan z'ye kadar ve ek olarak 0'dan 9'a kadar **\"rakamsal\"** ifade alabileceğidir. Bu kurala uyulması için metinsel ifade ne eksik ne fazla hiçbir şey olmaması gerekir.\n\nKuralımızın hemen aşağısındaki örnekte ise `\"kaan10\"` ifadesinde sadece 0-9 arası rakam (tek haneli) olması gerektiği için `false` çıktısını verdi.\n\n`\"emir6\"` ifade belirttiğimiz kurala uygun bir ifade olduğu için `true` çıktısını verdi.\n\n`\"gokhan\"` ifadesi içerisinde sayı barındırmadığı için `false` çıktısını verdi.\n\n`\"Altan2\"` ifadesi büyük harf ile başladığı için `false` çıktısını verdi.\n\n`\"8erkay\"` ifadesi ise rakam sonda olması gerekirken başta olduğu için `false` çıktısını verdi.\n\nBu yazıda regexp nasıl yazılırdan ziyade Go'da regexp'in kullanımını anlatmak istediğimden bu kısmı kısa tutuyorum. Regexp'in nasıl yazıldığına göz atmak isteyenler için aşağıda linkini paylaşıyorum. Buyursunlar:\n\n{% embed url=\"https://ceaksan.com/tr/regex-regular-expressions-nedir\" %}\n\nBu güzel anlatım için [Ceyhun Enki Aksan](https://ceaksan.com/)'a ayrıca teşekkür ederim.\n" }, { "path": "boeluem-6-paketler/sort-siralama.md", "content": "# Sort (Sıralama)\n\nGolang’ta dizilerin içeriğini sıralaya bileceğimiz bütünleşik olarak gelen **“sort**” isminde bir paket mevcuttur. Bu paketin kullanımı oldukça kolaydır. Örneğimizi görelim.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"sort\"\n)\nfunc main() {\n\tyazilar := []string{\"c\", \"a\", \"b\"}\n\tsort.Strings(yazilar)\n\tfmt.Println(\"Yazılar:\", yazilar)\n\tsayilar := []int{7, 2, 4}\n\tsort.Ints(sayilar)\n\tfmt.Println(\"Sayılar:\", sayilar)\n\tyazisirali := sort.StringsAreSorted(yazilar)\n\tfmt.Println(\"Yazılar Sıralandı mı?: \", yazisirali)\n\tsayisirali := sort.IntsAreSorted(sayilar)\n\tfmt.Println(\"Sayılar Sıralandı mı?:\", sayisirali)\n}\n```\n\nGelelim açıklamasına;\\\nSıralama özelliğini kullanabilmek için **“sort”** paketini içe aktardık. **main()** fonksiyonumuzun içini inceleyelim.\\\n**yazilar** isminde içerisinde rastgele harflereden oluşan bir **string** dizi oluşturduk. Hemen aşağısında **sort.Strings(yazilar)** diyerek sıralamanın **string** türünde olduğunu belirterek sıralamamızı yaptık. Altında **yazilar** değişkenimizi ekrana bastırdık.\n\n**sayilar** isminde içerisinde rastgele sayılar olan **int** tipinde bir dizi oluşturduk. Hemen aşağısında **sort.Ints(sayilar)** diyerek **int** tipinde sıralamamızı yaptık. Altında **sayilar** değişkenimizi ekrana bastırdık.\\\nDizilerin sıralı olup olmadığını öğrenmek için de aşağıdaki işlemleri yaptık.\\\n**yazisirali** değişkeninde **sort.StringsAreSorted(yazilar)** fonksiyonu ile **yazilar** dizisinin sıralı olup olmama durumuna göre **bool** değer aldık. Ve sonucu ekrana bastırdık.\\\n\n\n**sayisirali** değişkeninde **sort.IntsAreSorted(sayilar)** fonksiyonu ile **sayilar** dizisinin sıralı olup olmama durumuna göre **bool** değer aldık. Ve sonucu ekrana bastırdık.\\\nYukarıdaki işlemlere göre çıktımız şu şekilde olacaktır.\n\n> Yazılar: \\[a b c]\\\n> Sayılar: \\[2 4 7]\\\n> Yazılar Sıralandı mı?: true\\\n> Sayılar Sıralandı mı?: true\n" }, { "path": "boeluem-6-paketler/strconv-string-ceviri.md", "content": "# Strconv (String Çeviri)\n\n**strconv** paketi Golang ile bütünleşik gelen string tipi ve diğer tipler arasında çevirme işlemi yapabileceğimiz bir pakettir.\\\n\n\nİlk olarak `“strconv”` paketimizi içe aktarıyoruz.\\\nAşağıda örnek kullanımılarını ve daha açıklayıcı olması için yanlarına kullanım amaçlarını yazdım.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"strconv\"\n)\nfunc main() {\n\t//basit string-int arası çevirme\n\tsayi, _ := strconv.Atoi(\"-42\") //string > int\n\tyazi := strconv.Itoa(-42) //int > string\n\t//string'ten diğerlerine çevirme\n\tb, _ := strconv.ParseBool(\"true\") //string > bool\n\tf, _ := strconv.ParseFloat(\"3.1415\", 64) //string > float\n\ti, _ := strconv.ParseInt(\"-42\", 10, 64) //string > int\n\tu, _ := strconv.ParseUint(\"42\", 10, 64) //string > uint\n\t//diğerlerinden string'e çevirme\n\ts1 := strconv.FormatBool(true) //bool > string\n\ts2 := strconv.FormatFloat(3.1415, 'E', -1, 64) //float > string\n\ts3 := strconv.FormatInt(-42, 16) //int > string\n\ts4 := strconv.FormatUint(42, 16) //uint > string\n\t//Ekrana Yazdırma\n\tfmt.Printf(\"sayi: %d tip: %T\\n\", sayi, sayi)\n\tfmt.Printf(\"yazi: %s tip: %T\\n\", yazi, yazi)\n\tfmt.Printf(\"b: %t tip: %T\\n\", b, b)\n\tfmt.Printf(\"f: %f tip: %T\\n\", f, f)\n\tfmt.Printf(\"i: %d tip: %T\\n\", i, i)\n\tfmt.Printf(\"u: %d tip: %T\\n\", u, u)\n\tfmt.Printf(\"%T %T %T %T\", s1, s2, s3, s4)\n}\n```\n\nÇıktımız şu şekilde olacaktır.\n\n> sayi: -42 tip: int\\\n> yazi: -42 tip: string\\\n> b: true tip: bool\\\n> f: 3.141500 tip: float64\\\n> i: -42 tip: int64\\\n> u: 42 tip: uint64\\\n> string string string string\n" }, { "path": "boeluem-6-paketler/strings.md", "content": "# Strings\n\nStrings paketi ile **string** türünde değerler üzerinde işlemler yapabiliriz. Kısaca kullanımlarından bahsedelim.\\\n\n\n**Strings.Contains() Fonksiyonu**\\\n**Contains()** fonksiyonu ile istediğimiz bir string değerin içerisinde istediğimiz bir **string** değerin olup olmadığını kontrol edebiliriz. **Boolean** değer verir. Eğer varsa **true** değer döndürür. Yoksa **false** değer döndürür. Ufak bir uygulama örneği yapalım.\n\n```go\npackage main\nimport (\n \"fmt\"\n \"strings\"\n)\nfunc main() {\n var eposta string\n fmt.Print(\"E-posta adresinizi giriniz: \")\n fmt.Scan(&eposta)\n if strings.Contains(eposta, \"@\") {\n  fmt.Println(\"E-posta Adresiniz Onaylandı!\")\n } else {\n  fmt.Println(\"Geçerli Bir E-posta Adresi Giriniz!\")\n }\n}\n```\n\n**”strings”** paketini eklemeyi unutmuyoruz. Bu kodlar ile kullanıcıdan e-posta adresi isteyen ve e-posta adresi içinde **@** işareti var ise olumlu yanıt veren bir programcık oluşturduk. **Constains()** fonksiyonunu açıklayacak olursak, **Contains** fonksiyonunun ilk parametresine kontrol edeceğimiz öğeyi giriyoruz. İkinci parametreye ise aranılacak **string** ifademizi giriyoruz. Gayet anlaşılır olduğunu düşünüyorum.\\\n**Strings.Count() Fonksiyonu**\\\n**Count()** fonksiyonu ile bir string değerin içinde istediğimiz bir string değerin kaç tane olduğunu öğrenebiliriz. Örneğimize geçelim.\n\n```go\npackage main\nimport (\n \"fmt\"\n \"strings\"\n)\nfunc main() {\n fmt.Println(strings.Count(\"deneme\", \"e\"))\n}\n```\n\n**”strings”** paketini eklemeyi unutmuyoruz. Bu kodlar ile **Count()** fonksiyonunda **“deneme”** stringi içerisinde **“e”** stringinin kaç tane geçtiğini öğreniyoruz. Çıktımız **3** olacaktır.\\\n**Strings.Index() Fonksiyonu**\\\n**Index()** fonksiyonu ile bir **string** değerin içindeki istediğimiz bir string değerin kaçıncı sırada yani **index**’te olduğunu öğrenebiliriz.Sıra sıfırdan başlar. Örneğimize geçelim.\n\n```go\npackage main\nimport (\n \"fmt\"\n \"strings\"\n)\nfunc main() {\n fmt.Println(strings.Index(\"Merhaba Dünya\", \"h\"))\n}\n```\n\nÇıktımız **h** harfi **0**’dan başlayarak 3. sırada olduğu için, **3** olacaktır.\\\n**Strings.LastIndex() Fonksiyonu**\\\n**LastIndex()** fonksiyonu ile bir **string** değerin içinde istediğimiz bir string değerin sırasını **Index()** fonksiyonunun tersine sağdan sola doğru kontrol eder. İlk çıkan sonucun index’ini seçer. Örnek:\n\n```go\nfmt.Println(strings.LastIndex(\"Merhaba Dünya\", \"a\"))\n```\n\n**”Merhaba Dünya”** yazısının içinde **“a”** harfini aradık. **LastIndex()** fonksiyonu sondan başa yani sağdan sola arama yaptığı için sondaki **“a”** harfini buldu. Yani **13** sonucunu ekrana bastırmış olduk.\\\n**Strings.Title() Fonksiyonu**\\\n**Title()** fonksiyonu ile içerisine küçük harflerle string türünde değer girdiğimizde baş harfleri büyük harf yapan bir fonksiyondur.\n\n```go\nfmt.Println(strings.Title(\"merhaba dünya\"))\n```\n\nÇıktımız **“Merhaba Dünya”** olacaktır.\\\n**Strings.ToUpper() Fonksiyonu**\\\n**ToUpper()** fonksiyonu içerisine girilen string değerin tüm harflerini büyük harf yapar.\n\n```go\nfmt.Println(strings.ToUpper(\"merhaba dünya\"))\n```\n\nÇıktımız **“MERHABA DÜNYA”** olacaktır.\\\n**Strings.ToLower() Fonksiyonu**\\\n**ToLower()** fonksiyonu içerisine girilen string değerin tüm harflerini küçük harf yapar.\n\n```go\nfmt.Println(strings.ToLower(\"Merhaba Dünya\"))\n```\n\nÇıktımız **“merhaba dünya”** olacaktır.\\\n**Strings.ToUpperSpecial() Fonksiyonu**\\\n**ToUpper()** fonksiyonu ile string değeri büyük harf yaptığımız zaman Türkçe karakter sıkıntısı yaşarız. Örnek olarak **“i”** harfi büyüyünce **“I”** harfi olur. Bunun önüne **ToUpperSpecial()** fonksiyonu ile geçebiliriz. Bu fonksiyonun ilk parametresine **karakter kodlamasını**, ikinci parametresine ise **string** değerimizi gireriz. Örnek olarak:\n\n```go\nfmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, \"ıiüöç\"))\n```\n\nÇıktımız **“IİÜÖÇ”** olacaktır.\\\n**Strings.ToLowerSpecial() Fonksiyonu**\\\n**ToUpperSpecial()** fonksiyonu ile aynı seçilde çalışır ;fakat harfleri belirlediğiniz karakter kodlamasına göre küçültür. Örnek kullanımı:\n\n```go\nfmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, \"IİÜÖÇ\"))\n```\n\nÇıktımız **“ıiüöç”** olacaktır.\n" }, { "path": "boeluem-7-dosya-islemleri/bir-dizindeki-dosya-ve-klasoerleri-siralama.md", "content": "# Bir Dizindeki Dosya ve Klasörleri Sıralama\n\nGolang üzerinde adresini belirlediğimiz bir dizindeki dosya ve klasörleri listelemeyi göreceğiz. Örneğimize geçelim:\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"os\"\n)\nfunc diziniOku(d string) {\n\tdizin, err := os.Open(d)\n\tif err != nil {\n\t\tfmt.Println(\"Dizin bulunamadı!\")\n\t\tos.Exit(1)\n\t}\n\tdefer dizin.Close()\n\tliste, _ := dizin.Readdirnames(0) // Açıklamada okuyun\n\tfor _, isim := range liste {\n\t\tfmt.Println(isim)\n\t}\n\tfmt.Printf(\"Toplamda %d içerik bulundu.\\n\", len(liste))\n}\nfunc main() {\n\tdiziniOku(\".\")\n}\n```\n\nYukarıdaki kodlarımızın açıklamasını görelim:\\\nÖncelikle **“os”** paketimizi içe aktarıyoruz. **diziniOku()** fonksiyonumuzun içerisinde **dizin** adında değişken oluşturduk ve bu değişkende fonksiyonumuza **d** argümanı ile gelecek olan dizinimizi açtık. Eğer bir hata ile karşılaşırsak diye hata yakalama işlemini yaptık.\\\nDaha sonra **dizin** değişkenimizi **defer** ile kapattık.\\\n**liste** adında değişken oluşturduk. Bu değişkenimizin içerisine **dizin.Readdirnames(0)** diyerek tüm dosya ve klasörleri bu değişkenimizin içerisine attık. Burada sıfır kullanmamızın sebebi tüm dosya ve klasörleri okuyabilmek içindir.\\\n \\\nHemen aşağısında **for** ve **range** ile **liste** değişkenimizdeki dosya ve klasör isimlerini isim değişkenimize bastırmak istedik. Her dosya ve klasör ayrı ayrı isim değişkenimize atandı ve ekrana bastırılmış oldu.\\\n \\\nDaha sonra **diziniOku()** fonksiyonumuzun en altında **len(liste)** ile dosya sayımızı öğrenerek ekrana bastırdık.\\\n \\\n**main()** fonksiyonumuzda ise **diziniOku(“.”)** diyerek nokta ile bulunduğumuz dizini okuttuk.\n" }, { "path": "boeluem-7-dosya-islemleri/capraz-platform-dosya-yollari.md", "content": "# Çapraz Platform Dosya Yolları\n\nBir işletim sisteminde dosyanın veya dizinin yolunu belirtmek için taksim veya ters-taksim işaretleri kullanırız. Fakat yazağımız program çapraz-platformsa bu durumda ne yapmamız gerekir?\n\nYa kendimiz bunun için bir fonksiyon oluşturacağız ya da kısa yoldan `os.PathSeperator`'ı kullanabiliriz.\n\nHemen örneğimizi görelim:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n)\n\nfunc main() {\n\ts := string(os.PathSeparator)\n\tyol := \"dosyalar\" + s + \"muzikler\"\n\tfmt.Println(yol)\n}\n```\n\n{% hint style=\"info\" %}\nHer seferinde `string(os.PathSeperator)` yazmamak için `s` değişkenine atayarak kısalttık.\n{% endhint %}\n\nWindows için çıktımız:\n\n> dosyalar\\muzikler\n\nUnix-Like için çıktımız:\n\n> dosyalar/muzikler\n" }, { "path": "boeluem-7-dosya-islemleri/chromedp-web-driver.md", "content": "# chromedp (Web Driver)\n\n**Chromedp** paketi, harici bağımlılıklar (Selenium veya PhantomJS gibi) olmadan Go'da **Chrome DevTools Protokolü**nü destekleyen tarayıcıları çalıştırmanın daha hızlı ve daha basit bir yoludur. Harici bağımlılık yoktur derken, tabi ki sisteminizde Google Chrome'un yüklü olması gerekiyor. Chromedp'ye headless modu gerektiği için minimum Chrome sürümünüz 59 olması gerekiyor.\n\n#### Paketi yüklemek için:\n\n> go get -u github.com/chromedp/chromedp\n\n## Örnek.1\n\n```go\npackage main\n\nimport (\n\t\"context\"\n\t\"log\"\n\n\t\"github.com/chromedp/chromedp\"\n)\n\nfunc main() {\n\t//chrome örneği oluşturalım\n\tctx, cancel := chromedp.NewExecAllocator(\n\t\tcontext.Background(),\n\t\tappend(\n\t\t\tchromedp.DefaultExecAllocatorOptions[:],\n\t\t\tchromedp.Flag(\"headless\", false),\n\t\t)...,\n\t)\n\t//headless: false ayarlayarak pencerenin görünmesini istedik\n\t\n\t//chrome nesnesini defer ile kapatmayı unutmuyoruz\n\tdefer cancel()\n\n\t//yeni durum oluşturuyoruz\n\tctx, cancel = chromedp.NewContext(ctx)\n\n\t//aynı şekilde defer ile penceremizide kapatıyoruz\n\tdefer cancel()\n\n\t//Twitter isminin kaydedileceği değişkeni oluşturalım\n\tvar twitterName string\n\n\t//chromedp.Run() içerisinde tarayıcıda yapılacak işlemleri yazıyoruz.\n\terr := chromedp.Run(ctx, //önce durumu (hangi pencere) olacağını belirtiyoruz\n\n\t\t//tarayıcının gitmsini istediğimiz adresi yazalım\n\t\tchromedp.Navigate(`https://kaanksc.com/posts/webview-statik-uygulama-ornegi3/`),\n\t\t\n\t\t//css seçici ile belirttiğimiz elementin yüklenmesini bekleyelim\n\t\tchromedp.WaitVisible(`.single__contents > p:nth-child(16) > a:nth-child(1)`, chromedp.ByQuery),\n\t\t\n\t\t//Tıklanılacak nesneyi yine css seçici ile belirtelim\n\t\tchromedp.Click(`.single__contents > p:nth-child(16) > a:nth-child(1)`, chromedp.ByQuery),\n\t\t//Bu işlemden sonra twitter'a gidecek\n\n\t\t//Twitter profilinde adın gösterildiği yeri css seçici ile beklemesini istedik\n\t\tchromedp.WaitVisible(`div.r-1b6yd1w:nth-child(1) > span:nth-child(1)`, chromedp.ByQuery),\n\n\t\t//belirttiğimiz css seçicisi ile elementin içindeki yazıyı twitterName değişkenine atayalım\n\t\tchromedp.Text(`div.r-1b6yd1w:nth-child(1) > span:nth-child(1)`, &twitterName),\n\n\t\t//burdan sonra tarayıcı penceresi kapanacak\n\t)\n\n\t//hata kontrolü yapaım\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t//son olarak twitterName içindeki değişkeni ekrana bastıralım\n\tlog.Printf(\"Twitter İsim:%s\\n\", twitterName)\n}\n\n```\n\nYukarıdaki örnekte yeni chrome penceresi oluşturma, tıklama, elementin yüklenmesini bekleme, element içindeki yazıyı alma ve adrese gitme gibi işlemlerin nasıl yapıldığını gördük.\n\n## Örnek.2\n\nGo Playground linkinden Go kodlarını çeken bir uygulama yazalım.\n\n```go\npackage main\n\nimport (\n\t\"context\"\n\t\"log\"\n\n\t\"github.com/chromedp/chromedp\"\n)\n\nfunc main() {\n\t//chrome örneği oluşturalım\n\tctx, cancel := chromedp.NewExecAllocator(\n\t\tcontext.Background(),\n\t\tappend(\n\t\t\tchromedp.DefaultExecAllocatorOptions[:],\n\t\t\tchromedp.Flag(\"headless\", true), //Bu sefer headless çalışmasını istedik\n\t\t\t//yani chrome pecneresi açılmayacak\n\t\t)...,\n\t)\n\n\t//chrome nesnesini defer ile kapatmayı unutmuyoruz\n\tdefer cancel()\n\n\t//yeni durum oluşturuyoruz\n\tctx, cancel = chromedp.NewContext(ctx)\n\n\t//aynı şekilde defer ile penceremizide kapatıyoruz\n\tdefer cancel()\n\n\t//go Kodlarının kaydedileceği değişkeni oluşturalım\n\tvar goKodu string\n\n\t//chromedp.Run() içerisinde tarayıcıda yapılacak işlemleri yazıyoruz.\n\terr := chromedp.Run(ctx, //önce durumu (hangi pencere) olacağını belirtiyoruz\n\n\t\t//tarayıcının gitmsini istediğimiz adresi yazalım\n\t\tchromedp.Navigate(`https://play.golang.org/p/a_SoTzENmV7`),\n\n\t\t//tarayıcının yüklenemesini bekleyeceği elementi css seçici ile yazıyoruz\n\t\tchromedp.WaitVisible(`#code`, chromedp.ByQuery),\n\n\t\t//textContent ile yazı alanı içeriğini çekebiliriz.\n\t\tchromedp.TextContent(`#code`, &goKodu, chromedp.ByQuery),\n\t)\n\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\t//son oalrak go kodlarını ekrana bastıralım\n\tlog.Printf(\"Go Kodu:\\n%s\", goKodu)\n}\n\n```\n\nYukarıdaki örnekte headless modda çalışmayı ve yazı kutusu (input veya textarea) içindeki yazıları almayı öğrendik.\n\nDaha fazla bilgi için [https://github.com/chromedp/chromedp](https://github.com/chromedp/chromedp),\n\ndaha fazla örnek için [https://github.com/chromedp/examples](https://github.com/chromedp/examples) adresine bakabilirsiniz.\n" }, { "path": "boeluem-7-dosya-islemleri/dosya-varligi-kontrolue.md", "content": "# Dosya Varlığı Kontrolü\n\nGo programımızda kullancağımız bir bir dosyanın varlığını `os` paketi ile kontrol edebiliriz. Örnek programımızı görelim:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n)\n\nfunc main() {\n\tif d := \"dosya.txt\"; dosyaVarmı(d) {\n\t\tfmt.Println(d, \"bulunuyor\")\n\t} else {\n\t\tfmt.Println(d, \"bulunmuyor!\")\n\t}\n}\n\nfunc dosyaVarmı(isim string) bool {\n\tbilgi, hata := os.Stat(isim)\n\tif os.IsNotExist(hata) {\n\t\treturn false\n\t}\n\treturn !bilgi.IsDir()\n}\n```\n\n**Gelelim açıklmasına:**\n\nDosya işlemleri yapabilmek için `os` paketini import ettik. if-else akışında geçici değişken olarak `d` değişkenine `\"dosya.txt\"` atayarak kontrol edilecek dosyamızın ismini belirledik.\n\nBu akışta `dosyaVarmı` fonksiyonunda `true` değer dönerse `dosya.txt bulunuyor` olarak çıktı almamız gerekir.\n\n`dosyaVarmı` fonksiyonunu incelediğimizde `bilgi` ve `hata` değişkenlerine `os.Stat` ile dosyanın bilgilerini çektik. `hata` değişkeni `false` döndürürse fonksiyonun `false` döndürmesini istedik. Aynı şekilde `bilgi.IsDir()` ile dosya değil de bir dizinse `false` döndürmesini istedik.\n" }, { "path": "boeluem-7-dosya-islemleri/ini-dosyasi-okuma-ve-duezenleme.md", "content": "# ini Dosyası Okuma ve Düzenleme\n\nini dosyaları programımızın ayarlarını barındırabileceğimiz dosyalardır. Golang’de ini dosyalarını paket ekleyerek yapabiliriz. Paketimizi indirmek için aşağıdaki komutu yazıyoruz.\n\n> go get gopkg.in/ini.v1\n\nPaketimizi indirdikten sonra ini dosyamız üzerinde işlemler yapabiliriz.\\\nAşağıdaki örneklerde kullanacağımız ini dosyası bu şekildedir. Dosyamızın ismi **ayarlar.ini** olsun.\n\n```\n# Yorum satırımız\nuygulama_modu = geliştirme\n[dizinler]\nveri = ./dosyalar\n[sunucu]\nprotokol = http\nport = 8000\n```\n\n**Ini Dosyası Okuma**\n\nDosya okuma işlemimiz dizin mantığında çalışır. Örneğimizi görelim.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"gopkg.in/ini.v1\"\n)\nfunc kontrol(e error) {\n\tif e != nil {\n\t\tpanic(e)\n\t}\n}\nfunc main() {\n\tveri, err := ini.Load(\"ayarlar.ini\")\n\tkontrol(err)\n\tfmt.Println(\"Uygulama Modu:\", veri.Section(\"\").Key(\"uygulama_modu\").String())\n\tfmt.Println(\"Veri Dizini:\", veri.Section(\"dizinler\").Key(\"veri\").String())\n\tfmt.Println(\"Bağlantı Protokolü:\", veri.Section(\"sunucu\").Key(\"protokol\").String())\n\tfmt.Println(\"Bağlantı Portu:\", veri.Section(\"sunucu\").Key(\"port\").MustInt(9999))\n}\n```\n\nÇıktımız şu şekilde olacaktır.\n\n> Uygulama Modu: geliştirme\\\n> Veri Dizini: ./dosyalar\\\n> Bağlantı Protokolü: http\\\n> Bağlantı Portu: 8000\n\n\n\n**Inı Dosyası Düzenleme**\n\nYine aynı **ayarlar.ini** dosyası üzerinde düzenlemeler yapalım. İşte örneğimiz:\n\n```go\npackage main\nimport (\n\t\"gopkg.in/ini.v1\"\n)\nfunc kontrol(e error) {\n\tif e != nil {\n\t\tpanic(e)\n\t}\n}\nfunc main() {\n\tveri, err := ini.Load(\"ayarlar.ini\")\n\tkontrol(err)\n\t// Değer atıyoruz.\n\tveri.Section(\"\").Key(\"uygulama_modu\").SetValue(\"ürün\")\n\t// ini dosyamızı kaydetmeyi unutmuyoruz.\n\tveri.SaveTo(\"ayarlar.ini\")\n}\n```\n" }, { "path": "boeluem-7-dosya-islemleri/ioutil-ile-dosya-okuma-ve-yazma.md", "content": "# ioutil ile Dosya Okuma ve Yazma\n\n**ioutil** paketi standart Golang paketleri içerisinde gelir ve dosya işlemleri yapabilmemiz için bize fonksiyonlar sağlar.\n\n**Dosya Okuma**\n\nHemen örneğimize geçelim. Açıklamaları kod üzerinde ilgili alanlara yazdım.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"io/ioutil\"\n)\n// Hatayı kontrol etmek için fonksiyonumuz\nfunc kontrol(err error) {\n\tif err != nil {\n\t\tpanic(err)\n\t}\n}\nfunc main() {\n\t// Okunacak dosyamızı belirtiyoruz\n\tdosya, err := ioutil.ReadFile(\"dosya.txt\")\n\t// Hata kontrolü yapıyoruz.\n\tkontrol(err)\n\t//Dosyamızın içeriğini ekrana bastırıyoruz.\n\tfmt.Println(string(dosya))\n}\n```\n\n{% hint style=\"info\" %}\nOkuma işlemi **byte** tipinde yapıldığı için **string()** fonksiyonu ile byte tipini string tipine dönüştürüyoruz.\n{% endhint %}\n\n**Dosya Yazma**\n\n```go\npackage main\nimport (\n\t\"io/ioutil\"\n)\n// Hatayı kontrol etmek için fonksiyonumuz\nfunc kontrol(err error) {\n\tif err != nil {\n\t\tpanic(err)\n\t}\n}\nfunc main() {\n\t// Yazmak istediğimiz veriyi belirtiyoruz\n\tveri := []byte(\"golangtr.org\")\n\t// Dosya yazma işlemini başlatıyoruz.\n\terr := ioutil.WriteFile(\"dosya.txt\", veri, 0644) // 0644 dosya yazdırma izni oluyor.\n\t// Hata kontrolü yapıyoruz.\n\tkontrol(err)\n}\n```\n\n{% hint style=\"info\" %}\nString tipini dosyaya yazdırmamız için önce byte tipine çevirmemiz gerekir.\n{% endhint %}\n\nDosya yazdırma işleminde aynı isimde dosya varsa üzerine yazar.\n" }, { "path": "boeluem-7-dosya-islemleri/isletim-sistemini-goerme.md", "content": "# İşletim Sistemini Görme\n\nGo programının çalıştığı işletim sistemi görmek için aşağıdaki kodları yazabilirsiniz.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nfunc main() {\n\n\tif r := runtime.GOOS; r == \"windows\" {\n\t\tfmt.Println(\"Windows için yönetici olarak çalıştırın.\")\n\t} else if r == \"linux\" {\n\t\tfmt.Println(\"Linux için sudo komutu ile çalıştırın.\")\n\t} else {\n\t\tfmt.Println(\"Geçersiz işletim sistemi!\")\n\t}\n}\n```\n\nGNU/Linux kullandığım için çıktım aşağıdaki gibi olacaktır.\n\n> Linux için sudo komutu ile çalıştırın.\n" }, { "path": "boeluem-7-dosya-islemleri/json-parsing-ayristirma/README.md", "content": "# JSON Parsing (Ayrıştırma)\n\n{% hint style=\"info\" %}\nYazıya başlamadan önce bu konuyu yazdığı için **Latif Uluman**'a ([@latif70427517](https://twitter.com/latif70427517)) teşekkürlerimi sunarım.\n{% endhint %}\n\nBugünkü yazımızda _Golang_ ile _**JSON**_ parse etmeye bakacağız. Hepimizin bildiği gibi günümüzde bir _API_ (_application programming interface_) a veri göndermede ya da veri çekmede en sık kullanılan veri formatı _JSON_ (_javascript object notation_) dur. _Golang_ ile de kendi oluşturduğumuz verimizi (_Golang struct_) _JSON’a_ dönüştürüp bir _API’a_ request olarak gönderebilir ya da bir _API’dan_ gelen _JSON_ verisini Go programımızda kullanabiliriz. O halde çok uzatmadan Go programımızdaki verileri nasıl _JSON’a_ dönüştürüz hemen bakalım:\n\n**MARSHALLING (Sıralama)**\n\nEvet Go programında _Go struct’ını_ JSON stringine dönüştürmek için **“encoding”** altındaki **“json”** paketini kullanıyoruz. Kullanıma ait kod örneği aşağıdaki gibidir.\n\n```go\npackage main\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log\"\n)\ntype kişi struct {\n\tisim string\n\tsoyisim string\n\tyaş int\n}\nfunc main() {\n\tali := kişi{\n\t\tisim: \"Ali\",\n\t\tsoyisim: \"Veli\",\n\t\tyaş: 20,\n\t}\n\tveri, err := json.Marshal(ali)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t\treturn\n\t}\n\tfmt.Printf(\"JSON Parse Sonucu: %s\", string(veri))\n}\n```\n\n \\\nŞimdi de kodumuzu çalıştıralım ve sonucu görelim:\n\n> JSON Parse Sonucu: {}\n\nÇıktımıza baktığımızda bir hata olmamasına rağmen JSON string’i boş görüyoruz. Yani marshalling başarılı olmuş gözüküyor; fakat boş bir struct’ı marshal etmiş gibi gözüküyor.\\\nEvet durum tam da böyle. JSON marshal **sadece dışa aktarılmış (exported)** verileri marshal eder. Bildiğimiz gibi Golang’de export etmek için değişken ismi büyük harfle yazılmalıdır. İlk kodumuzda struct elemanlarının baş harflerini küçük yazdığımız için hiçbiri export edilmedi. Bu yüzden aslında boş bir struct ı marshal etmeye çalışıyoruz gibi algıladı Json.Marshal() fonksiyonu. Doğal olarak geriye boş bir JSON döndü. Haydi şimdi struct elemanlarının tamamını export ederek yani ilk harflerini büyük yazarak test edelim:\n\n```go\npackage main\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log\"\n)\ntype kişi struct {\n\tİsim string\n\tSoyisim string\n\tYaş int\n}\nfunc main() {\n\tali := kişi{\n\t\tİsim: \"Ali\",\n\t\tSoyisim: \"Veli\",\n\t\tYaş: 20,\n\t}\n\tveri, err := json.Marshal(ali)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t\treturn\n\t}\n\tfmt.Printf(\"JSON Parse Sonucu: %s\", string(veri))\n}\n```\n\nVe tekrar kodumuzu derleyelim ve sonucu görelim:\n\n> JSON Parse Sonucu: {\"İsim\":\"Ali\",\"Soyisim\":\"Veli\",\"Yaş\":20}\n\nEvet arkadaşlar görüldüğü gibi kodumuz çalıştı. Şimdi kısaca açıklayalım programımızı:\\\n**7-11** satırlarda kendi **“kişi”** tipimizi oluşturduk. **13-17** satırlarda bu tipte bir örnek oluşturduk ve **ali** değişkenine atadık. Daha sonra ali değişkenimizi **json.Marshal()** fonksiyonu kullanarak JSON’a parse ettik. Bu fonksiyondan bize 2 değer dönmektedir. Bunların bir tanesi **\\[]byte** tipinde parse edilen verimiz, diğeri ise **error** tipinde hata durumunu gösteren mesajdır. **19-22** satırlarda hatayı kontrol ettik. Ve son olarak da hatalı değilse ekrana bastık. Tabii bizim datamız \\[]byte tipindeydi, bunu daha okunur hale getirmek için string’e dönüştürdük.\\\n \\\nEvet işte bu kadar. Peki diyelim ki JSON string imizi test etmek istiyoruz ve elimizde oldukça karmaşık bir string var. Bunu tek bir satırda incelemek oldukça zahmetli olabilir. İşte bu durumda imdadımıza **json.MarshalIndent()** fonksiyonu yetişiyor. Kullanımı aşağıdaki gibidir:\n\n```go\nfunc main() {\n\tali := kişi{\n\t\tİsim: \"Ali\",\n\t\tSoyisim: \"Veli\",\n\t\tYaş: 20,\n\t}\n\tveri, err := json.MarshalIndent(ali, \"\", \" \")\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t\treturn\n\t}\n\tfmt.Printf(\"JSON Parse Sonucu:\\n%s\", string(veri))\n}\n```\n\nGörüldüğü gibi JSON için yeni bir fonksiyon kullandık. Dikkatimizi çeken bir şey fonksiyonun ek olarak 2 paremetre içermesidir. Bunlardan ilki yani 2. parametremiz prefix olarak geçmektedir. Yani 2. parametre her satırın başına gelmektedir. 2. si ise yani 3. parametremiz indentation olarak geçmektedir. Ben onu 4 boşluk olarak ayarladım. Şimdi programımızı tekrar çalıştıralım:\n\n> JSON Parse Sonucu:\\\n> {\\\n> \"İsim\": \"Ali\",\\\n> \"Soyisim\": \"Veli\",\\\n> \"Yaş\": 20\\\n> }\n\nGörüldüğü gibi ekrana basarken indentation ekleyerek bastı.\\\nEvet **“encoding/json”** paketi ile go struct’ımızı nasıl JSON’a parse edeceğimizi gördük. Artık JSON datamızı istediğimiz gibi kullanabiliriz.\\\nPeki tam tersi olsaydı nasıl olurdu? Yani elimizde bir JSON verisi var. Bu bir sorgunun sonucu olabilir. Bunu Go struct’ımıza nasıl çevireceğiz? Çözüm: UNMARSHALL\n\n**UNMARSHALL**\n\nEvet arkadaşlar unmarshal işlemi amaç olarak marshal işleminin tam tersidir. Elimizde JSON formatında bir veri vardır ve biz bunu Go struct’ına dönüştürmek istiyoruz. Bunun için **“encoding/json”** paketinde **Unmarshal** fonksiyonunu kullanırız. O halde çok uzatmadan koda bakalım:\n\n```go\npackage main\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log\"\n)\ntype kişi struct {\n\tİsim string\n\tSoyisim string\n\tYaş int\n}\nfunc main() {\n\tjsonVeri := []byte(`{\"İsim\":\"Latif\",\"Soyisim\":\"Uluman\",\"Yaş\":23}`)\n\tvar goVeri kişi\n\terr := json.Unmarshal(jsonVeri, &goVeri)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\tfmt.Printf(\"İsim - Soyisim: %s %s\\nYaş: %d\", goVeri.İsim, goVeri.Soyisim, goVeri.Yaş)\n}\n```\n\nEvet görüldüğü gibi string formatındaki JSON verimizi önce **\\[]byte** formatına çevirdik sonra onu **Unmarshal** fonksiyonuna parametre olarak verdik. Sonucu da referansını verdiğimiz kişi türündeki **goVeri** değişkenine yazmak istedik. Ve **goVeri.İsim**, **goVeri.Soyisim** ve **goVeri.Yaş** ile bunlara erişmeye çalıştık. Bakalım sonuçlar nasıl:\n\n> İsim - Soyisim: Latif Uluman\\\n> Yaş: 23\n\nGörüldüğü gibi Unmarshal işlemi başarılı bir şekilde gerçekleşti.\\\nPeki bir API’ dan gelen JSON verimize ait özellikleri (attribute) tam olarak bilmeseydik nasıl bir yol izlememiz gerekirdi? Yani biz burada API’ dan isim-soyisim-yas özelliklerinin geleceğini biliyoruz; fakat bunları bilmeyebilirdik. Bu durumda unmarshal ı hangi türden bir veri tipine gerçeklememiz gerekiyor?\\\nÇözüm: “**map**” . Evet _**map**_ kullanabiliriz. Yani _**key-value**_ (anahtar-değer) ler işimizi görür. Peki türleri ne olmalıdır. “key” ler için düşündüğümüzde bu string olacağı hepimizin aklına gelecektir. Peki Value lar ne olmalıdır? Görüldüğü gibi isim türü string iken, yas integer dı. O halde hepsini karşılayabilen bir veri türü olması lazım. Aklınızda bir şeyler canlanıyor mu? Evet yardımımıza interface yetişiyor. O halde map imizin türü **map\\[string]interface{}** olabilir.Hemen bunu da bir kod örneği ile görelim:\n\n```go\npackage main\nimport(\n \"encoding/json\"\n \"fmt\"\n)\nfunc main(){\n jsonVeri := []byte(`{\"İsim\":\"Latif\",\"Soyisim\":\"Uluman\" ,\"Yas\":23 , \"Kilo\":80.25}`)\n var goVeri map[string]interface{}\n err := json.Unmarshal(jsonVeri ,&goVeri )\n if (err != nil){\n fmt.Printf(\"%+v\" , err.Error())\n return\n }\n fmt.Printf(\"İsim: %+v \\nSoyisim: %+v \\nYas:%+v\\nKilo:%+v\" , goVeri[\"İsim\"] , goVeri[\"Soyisim\"] , goVeri[\"Yas\"] , goVeri[\"Kilo\"])\n}\n```\n\nProgramımızı çalıştırıp sonucu görelim:\n\n> İsim: Latif\\\n> Soyisim: Uluman\\\n> Yas:23\\\n> Kilo:80.25\n\nEvet görüldüğü gibi farklı türden veri tipleri olan bir json string ini go map ine dönüştürdük ve key değerleri ile de değerlere ulaştık.Evet arkadaşlar bu yazımızda nasıl bir go verisini json verisine döönüştürüp kullanacağımızı ya da tam tersi json verisini go verisine dönüştüreceğimizi gördük.\n" }, { "path": "boeluem-7-dosya-islemleri/json-parsing-ayristirma/dinamik-json-parsing-yoentemleri.md", "content": "# Dinamik JSON Parsing Yöntemleri\n\nBazı durumlarda struct ile JSON parse etme uğraştırıcı olabiliyor. Özellikle json verisi olarak hangi tipte veri geleceğini bilmediğimiz durumlarda.\n\n## Map ve Boş Interface Kullanarak\n\n```go\npackage main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n)\n\nfunc main() {\n\t//Öncelikle json düzeninde bir string oluşturalım\n\tfutbolcuJson := `{\n \"formaNo\" : 10,\n \"isim\" : \"Hakan Çalhanoğlu\",\n \"ülke\" : \"TR\",\n \"mevki\" : \"Orta Saha\"\n\t}`\n\n\t// Map ve boş interface ile bir örnek oluşturalım\n\tvar futbolcu map[string]interface{}\n\n\t//fulbolcuJson string ini futbolcu örneğini parse edelim\n\tjson.Unmarshal([]byte(futbolcuJson), &futbolcu)\n\n\t//Oluşturduğumuz örneği bölümleri ile ekrana bastıralım\n\tfmt.Println(\"Forma No :\", futbolcu[\"formaNo\"],\n\t\t\"\\nİsim :\", futbolcu[\"isim\"],\n\t\t\"\\nÜlke :\", futbolcu[\"ülke\"],\n\t\t\"\\nMevki :\", futbolcu[\"mevki\"])\n}\n```\n\n### Çıktımız\n\n```go\nForma No : 10 \nİsim : Hakan Çalhanoğlu \nÜlke : TR \nMevki : Orta Saha\n```\n\n## Dizi Şeklinde Map ve Boş Interface Kullanarak\n\n```go\npackage main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n)\n\nfunc main() {\n\t//Bu sefer futbolcuları json içerisinde dizi\n\t//olarak tanımladık\n\tfutbolcularJson := `[\n\t\t{\n\t\t\t\"formaNo\": 10,\n\t\t\t\"isim\": \"Hakan Çalhanoğlu\",\n\t\t\t\"ülke\": \"TR\",\n\t\t\t\"mevki\": \"Orta Saha\"\n\t\t},\n\t\t{\n\t\t\t\"formaNo\": 11,\n\t\t\t\"isim\": \"Yusuf Yazıcı\",\n\t\t\t\"ülke\": \"TR\",\n\t\t\t\"mevki\": \"Forvet\"\n\t\t},\n\t\t{\n\t\t\t\"formaNo\": 23,\n\t\t\t\"isim\": \"Uğurcan Çakır\",\n\t\t\t\"ülke\": \"TR\",\n\t\t\t\"mevki\": \"Kaleci\"\n\t\t}\n\t]`\n\n\t// Map'imizi boş interface ile dizi olarak oluşturalım\n\tvar futbolcular []map[string]interface{}\n\n\t// Unmarshall işlemi\n\tjson.Unmarshal([]byte(futbolcularJson), &futbolcular)\n\n\t//for döngüsü ile tüm futbolcuları ekrana bastıralım\n\tfor index, futbolcu := range futbolcular {\n\n\t\tfmt.Printf(\"%d. sıradaki futbolcu:\\n\", index+1)\n\t\tfmt.Println(\"Forma No :\", futbolcu[\"formaNo\"],\n\t\t\t\"- İsim :\", futbolcu[\"isim\"],\n\t\t\t\"- Ülke :\", futbolcu[\"ülke\"],\n\t\t\t\"- Mevki :\", futbolcu[\"mevki\"])\n\t}\n}\n```\n\n### Çıktımız\n\n```go\n1. sıradaki futbolcu:\nForma No : 10 - İsim : Hakan Çalhanoğlu - Ülke : TR - Mevki : Orta Saha\n2. sıradaki futbolcu:\nForma No : 11 - İsim : Yusuf Yazıcı - Ülke : TR - Mevki : Forvet\n3. sıradaki futbolcu:\nForma No : 23 - İsim : Uğurcan Çakır - Ülke : TR - Mevki : Kaleci\n```\n\n## Map ve Boş String ile İç-içe JSON Verisi Okuma\n\n```go\npackage main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n)\n\nfunc main() {\n\t//İç içe bir Json verisi oluşturalım\n\tfutbolcuJson := `{\n\t\t\"formaNo\": 10,\n\t\t\"isim\": \"Hakan Çalhanoğlu\",\n\t\t\"ülke\": \"TR\",\n\t\t\"mevki\": \"Orta Saha\",\n\t\t\"istatistik\": {\n\t\t\t\"gol\": 12,\n\t\t\t\"asist\": 7,\n\t\t\t\"cezalı\": false\n\t\t}\n\t}`\n\n\t// Örneğimizi oluşturalım\n\tvar futbolcu map[string]interface{}\n\n\t// Parsing'i yapalım\n\tjson.Unmarshal([]byte(futbolcuJson), &futbolcu)\n\n\tistatistik := futbolcu[\"istatistik\"].(map[string]interface{})\n\n\t//Değerleri Anahtarlar ile okuyalım.\n\tfmt.Println(\"Forma No :\", futbolcu[\"formaNo\"],\n\t\t\"\\nİsim :\", futbolcu[\"isim\"],\n\t\t\"\\nÜlke :\", futbolcu[\"ülke\"],\n\t\t\"\\nMevki :\", futbolcu[\"mevki\"],\n\t\t\"\\nİstatistik : (Gol:\", istatistik[\"gol\"], \"- Asist:\", istatistik[\"asist\"], \"- Cezalı:\", istatistik[\"cezalı\"], \")\")\n}\n```\n\n### Çıktımız\n\n```go\nForma No : 10 \nİsim : Hakan Çalhanoğlu \nÜlke : TR \nMevki : Orta Saha \nİstatistik : (Gol: 12 - Asist: 7 - Cezalı: false )\n```\n\n## Map ve Boş String ile İç-içe Dizi JSON Verisi Okuma\n\n```go\npackage main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n)\n\nfunc main() {\n\t//İç-içe veriler saklayan dizi Json verisi\n\tfutbolcularJson := `[\n\t\t{\n\t\t\"formaNo\": 10,\n\t\t\"isim\": \"Hakan Çalhanoğlu\",\n\t\t\"ülke\": \"TR\",\n\t\t\"mevki\": \"Orta Saha\",\n\t\t\"istatistik\": {\n\t\t\t\"gol\": 12,\n\t\t\t\"asist\": 7,\n\t\t\t\"cezalı\": false\n\t\t\t}\n\t\t},\n\t\t{\n\t\t\"formaNo\": 11,\n\t\t\"isim\": \"Yusuf Yazıcı\",\n\t\t\"ülke\": \"TR\",\n\t\t\"mevki\": \"Forvet\",\n\t\t\"istatistik\": {\n\t\t\t\"gol\": 17,\n\t\t\t\"asist\": 9,\n\t\t\t\"cezalı\": true\n\t\t\t}\n\t\t},\n\t\t{\n\t\t\"formaNo\": 23,\n\t\t\"isim\": \"Uğurcan Çakır\",\n\t\t\"ülke\": \"TR\",\n\t\t\"mevki\": \"Kaleci\",\n\t\t\"istatistik\": {\n\t\t\t\"gol\": 0,\n\t\t\t\"asist\": 2,\n\t\t\t\"cezalı\": false\n\t\t\t}\n\t\t}\n\t]`\n\n\t// Futbolcu dizimizi tanımlayalım\n\tvar futbolcular []map[string]interface{}\n\n\t// Unmarshall işlemi\n\tjson.Unmarshal([]byte(futbolcularJson), &futbolcular)\n\n\tfor index, futbolcu := range futbolcular {\n\t\t//futbolcuya özel istatistiklerimizi kullanmak için\n\t\t//map'imizi oluşturalım\n\t\tistatistik := futbolcu[\"istatistik\"].(map[string]interface{})\n\t\t//Futbolcunun bilgilerini ekrana bastıralım\n\t\tfmt.Printf(\"%d. Futbolcu --------------------\\n\", index+1)\n\t\tfmt.Println(\"Forma No :\", futbolcu[\"formaNo\"],\n\t\t\t\"\\nİsim :\", futbolcu[\"isim\"],\n\t\t\t\"\\nÜlke :\", futbolcu[\"ülke\"],\n\t\t\t\"\\nMevki :\", futbolcu[\"mevki\"],\n\t\t\t\"\\nİstatistik : (Gol:\", istatistik[\"gol\"], \"- Asist:\", istatistik[\"asist\"], \"- Cezalı:\", istatistik[\"cezalı\"], \")\")\n\t}\n\n}\n```\n\n### Çıktımız\n\n```go\n1. Futbolcu --------------------\nForma No : 10 \nİsim : Hakan Çalhanoğlu \nÜlke : TR \nMevki : Orta Saha \nİstatistik : (Gol: 12 - Asist: 7 - Cezalı: false )\n2. Futbolcu --------------------\nForma No : 11 \nİsim : Yusuf Yazıcı \nÜlke : TR \nMevki : Forvet \nİstatistik : (Gol: 17 - Asist: 9 - Cezalı: true )\n3. Futbolcu --------------------\nForma No : 23 \nİsim : Uğurcan Çakır \nÜlke : TR \nMevki : Kaleci \nİstatistik : (Gol: 0 - Asist: 2 - Cezalı: false )\n```\n" }, { "path": "boeluem-7-dosya-islemleri/json-parsing-ayristirma.md", "content": "# JSON Parsing \\(Ayrıştırma\\)\n\n{% hint style=\"info\" %}\nYazıya başlamadan önce bu konuyu yazdığı için **Latif Uluman**'a \\([@latif70427517](https://twitter.com/latif70427517)\\) teşekkürlerimi sunarım.\n{% endhint %}\n\nBugünkü yazımızda _Golang_ ile _**JSON**_ parse etmeye bakacağız. Hepimizin bildiği gibi günümüzde bir _API_ \\(_application programming interface_\\) a veri göndermede ya da veri çekmede en sık kullanılan veri formatı _JSON_ \\(_javascript object notation_\\) dur. _Golang_ ile de kendi oluşturduğumuz verimizi \\(_Golang struct_\\) _JSON’a_ dönüştürüp bir _API’a_ request olarak gönderebilir ya da bir _API’dan_ gelen _JSON_ verisini Go programımızda kullanabiliriz. O halde çok uzatmadan Go programımızdaki verileri nasıl _JSON’a_ dönüştürüz hemen bakalım:\n\n**MARSHALLING \\(Sıralama\\)**\n\nEvet Go programında _Go struct’ını_ JSON stringine dönüştürmek için **“encoding”** altındaki **“json”** paketini kullanıyoruz. Kullanıma ait kod örneği aşağıdaki gibidir.\n\n```go\npackage main\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log\"\n)\ntype kişi struct {\n\tisim string\n\tsoyisim string\n\tyaş int\n}\nfunc main() {\n\tali := kişi{\n\t\tisim: \"Ali\",\n\t\tsoyisim: \"Veli\",\n\t\tyaş: 20,\n\t}\n\tveri, err := json.Marshal(ali)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t\treturn\n\t}\n\tfmt.Printf(\"JSON Parse Sonucu: %s\", string(veri))\n}\n```\n\n \nŞimdi de kodumuzu çalıştıralım ve sonucu görelim:\n\n> JSON Parse Sonucu: {}\n\nÇıktımıza baktığımızda bir hata olmamasına rağmen JSON string’i boş görüyoruz. Yani marshalling başarılı olmuş gözüküyor; fakat boş bir struct’ı marshal etmiş gibi gözüküyor. \nEvet durum tam da böyle. JSON marshal **sadece dışa aktarılmış \\(exported\\)** verileri marshal eder. Bildiğimiz gibi Golang’de export etmek için değişken ismi büyük harfle yazılmalıdır. İlk kodumuzda struct elemanlarının baş harflerini küçük yazdığımız için hiçbiri export edilmedi. Bu yüzden aslında boş bir struct ı marshal etmeye çalışıyoruz gibi algıladı Json.Marshal\\(\\) fonksiyonu. Doğal olarak geriye boş bir JSON döndü. Haydi şimdi struct elemanlarının tamamını export ederek yani ilk harflerini büyük yazarak test edelim:\n\n```go\npackage main\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log\"\n)\ntype kişi struct {\n\tİsim string\n\tSoyisim string\n\tYaş int\n}\nfunc main() {\n\tali := kişi{\n\t\tİsim: \"Ali\",\n\t\tSoyisim: \"Veli\",\n\t\tYaş: 20,\n\t}\n\tveri, err := json.Marshal(ali)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t\treturn\n\t}\n\tfmt.Printf(\"JSON Parse Sonucu: %s\", string(veri))\n}\n```\n\nVe tekrar kodumuzu derleyelim ve sonucu görelim:\n\n> JSON Parse Sonucu: {\"İsim\":\"Ali\",\"Soyisim\":\"Veli\",\"Yaş\":20}\n\nEvet arkadaşlar görüldüğü gibi kodumuz çalıştı. Şimdi kısaca açıklayalım programımızı: \n**7-11** satırlarda kendi **“kişi”** tipimizi oluşturduk. **13-17** satırlarda bu tipte bir örnek oluşturduk ve **ali** değişkenine atadık. Daha sonra ali değişkenimizi **json.Marshal\\(\\)** fonksiyonu kullanarak JSON’a parse ettik. Bu fonksiyondan bize 2 değer dönmektedir. Bunların bir tanesi **\\[\\]byte** tipinde parse edilen verimiz, diğeri ise **error** tipinde hata durumunu gösteren mesajdır. **19-22** satırlarda hatayı kontrol ettik. Ve son olarak da hatalı değilse ekrana bastık. Tabii bizim datamız \\[\\]byte tipindeydi, bunu daha okunur hale getirmek için string’e dönüştürdük. \n \nEvet işte bu kadar. Peki diyelim ki JSON string imizi test etmek istiyoruz ve elimizde oldukça karmaşık bir string var. Bunu tek bir satırda incelemek oldukça zahmetli olabilir. İşte bu durumda imdadımıza **json.MarshalIndent\\(\\)** fonksiyonu yetişiyor. Kullanımı aşağıdaki gibidir:\n\n```go\nfunc main() {\n\tali := kişi{\n\t\tİsim: \"Ali\",\n\t\tSoyisim: \"Veli\",\n\t\tYaş: 20,\n\t}\n\tveri, err := json.MarshalIndent(ali, \"\", \" \")\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t\treturn\n\t}\n\tfmt.Printf(\"JSON Parse Sonucu:\\n%s\", string(veri))\n}\n```\n\nGörüldüğü gibi JSON için yeni bir fonksiyon kullandık. Dikkatimizi çeken bir şey fonksiyonun ek olarak 2 paremetre içermesidir. Bunlardan ilki yani 2. parametremiz prefix olarak geçmektedir. Yani 2. parametre her satırın başına gelmektedir. 2. si ise yani 3. parametremiz indentation olarak geçmektedir. Ben onu 4 boşluk olarak ayarladım. Şimdi programımızı tekrar çalıştıralım:\n\n> JSON Parse Sonucu: \n> { \n> \"İsim\": \"Ali\", \n> \"Soyisim\": \"Veli\", \n> \"Yaş\": 20 \n> }\n\nGörüldüğü gibi ekrana basarken indentation ekleyerek bastı. \nEvet **“encoding/json”** paketi ile go struct’ımızı nasıl JSON’a parse edeceğimizi gördük. Artık JSON datamızı istediğimiz gibi kullanabiliriz. \nPeki tam tersi olsaydı nasıl olurdu? Yani elimizde bir JSON verisi var. Bu bir sorgunun sonucu olabilir. Bunu Go struct’ımıza nasıl çevireceğiz? Çözüm: UNMARSHALL\n\n**UNMARSHALL**\n\nEvet arkadaşlar unmarshal işlemi amaç olarak marshal işleminin tam tersidir. Elimizde JSON formatında bir veri vardır ve biz bunu Go struct’ına dönüştürmek istiyoruz. Bunun için **“encoding/json”** paketinde **Unmarshal** fonksiyonunu kullanırız. O halde çok uzatmadan koda bakalım:\n\n```go\npackage main\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log\"\n)\ntype kişi struct {\n\tİsim string\n\tSoyisim string\n\tYaş int\n}\nfunc main() {\n\tjsonVeri := []byte(`{\"İsim\":\"Latif\",\"Soyisim\":\"Uluman\",\"Yaş\":23}`)\n\tvar goVeri kişi\n\terr := json.Unmarshal(jsonVeri, &goVeri)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\tfmt.Printf(\"İsim - Soyisim: %s %s\\nYaş: %d\", goVeri.İsim, goVeri.Soyisim, goVeri.Yaş)\n}\n```\n\nEvet görüldüğü gibi string formatındaki JSON verimizi önce **\\[\\]byte** formatına çevirdik sonra onu **Unmarshal** fonksiyonuna parametre olarak verdik. Sonucu da referansını verdiğimiz kişi türündeki **goVeri** değişkenine yazmak istedik. Ve **goVeri.İsim**, **goVeri.Soyisim** ve **goVeri.Yaş** ile bunlara erişmeye çalıştık. Bakalım sonuçlar nasıl:\n\n> İsim - Soyisim: Latif Uluman \n> Yaş: 23\n\nGörüldüğü gibi Unmarshal işlemi başarılı bir şekilde gerçekleşti. \nPeki bir API’ dan gelen JSON verimize ait özellikleri \\(attribute\\) tam olarak bilmeseydik nasıl bir yol izlememiz gerekirdi? Yani biz burada API’ dan isim-soyisim-yas özelliklerinin geleceğini biliyoruz; fakat bunları bilmeyebilirdik. Bu durumda unmarshal ı hangi türden bir veri tipine gerçeklememiz gerekiyor? \nÇözüm: “**map**” . Evet _**map**_ kullanabiliriz. Yani _**key-value**_ \\(anahtar-değer\\) ler işimizi görür. Peki türleri ne olmalıdır. “key” ler için düşündüğümüzde bu string olacağı hepimizin aklına gelecektir. Peki Value lar ne olmalıdır? Görüldüğü gibi isim türü string iken, yas integer dı. O halde hepsini karşılayabilen bir veri türü olması lazım. Aklınızda bir şeyler canlanıyor mu? Evet yardımımıza interface yetişiyor. O halde map imizin türü **map\\[string\\]interface{}** olabilir.Hemen bunu da bir kod örneği ile görelim:\n\n```go\npackage main\nimport(\n \"encoding/json\"\n \"fmt\"\n)\nfunc main(){\n jsonVeri := []byte(`{\"İsim\":\"Latif\",\"Soyisim\":\"Uluman\" ,\"Yas\":23 , \"Kilo\":80.25}`)\n var goVeri map[string]interface{}\n err := json.Unmarshal(jsonVeri ,&goVeri )\n if (err != nil){\n fmt.Printf(\"%+v\" , err.Error())\n return\n }\n fmt.Printf(\"İsim: %+v \\nSoyisim: %+v \\nYas:%+v\\nKilo:%+v\" , goVeri[\"İsim\"] , goVeri[\"Soyisim\"] , goVeri[\"Yas\"] , goVeri[\"Kilo\"])\n}\n```\n\nProgramımızı çalıştırıp sonucu görelim:\n\n> İsim: Latif \n> Soyisim: Uluman \n> Yas:23 \n> Kilo:80.25\n\nEvet görüldüğü gibi farklı türden veri tipleri olan bir json string ini go map ine dönüştürdük ve key değerleri ile de değerlere ulaştık.Evet arkadaşlar bu yazımızda nasıl bir go verisini json verisine döönüştürüp kullanacağımızı ya da tam tersi json verisini go verisine dönüştüreceğimizi gördük.\n\n" }, { "path": "boeluem-7-dosya-islemleri/web-scrapper.md", "content": "# Web Scrapper (goquery)\n\nBu yazıda Go dilinde nasıl basitçe web scrapper yapacağımıza bakacağız.\n\n### Web Scrapper Nedir?\n\nWeb Scrapper bir web sayfasındaki elementleri işleyen araçtır.\n\n**Örnek uygulama:**\n\n**blog.golang.org** sitesindeki blog başlıklarını listeleyen Go programının yazılması.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"log\"\n\t\"net/http\"\n\n\t\"github.com/PuerkitoBio/goquery\"\n)\n\nfunc main() {\n\tblogBasliklari, err := baslikCek(\"https://blog.golang.org\")\n\tif err != nil {\n\t\tlog.Println(err)\n\t}\n\tfmt.Println(\"Başlıklar:\")\n\tfmt.Printf(blogBasliklari)\n}\n\n// URL adresinden blog başlıklarını çekecek fonksiyon\nfunc baslikCek(url string) (string, error) {\n\n\t// HTML'i çek\n\tresp, err := http.Get(url)\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\n\t// goquery dökümanına çevir\n\tdoc, err := goquery.NewDocumentFromReader(resp.Body)\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\n\t// liste oluştur\n\tbasliklar := \"\"\n\tdoc.Find(\".title a\").Each(func(i int, s *goquery.Selection) {\n\t\tbasliklar += \"- \" + s.Text() + \"\\n\"\n\t})\n\treturn basliklar, nil\n}\n\n```\n\nAçıklaması:\\\ngoquery kütüphanesini bilgisayarımıza indiriyoruz.\n\n> go get github.com/PuerkitoBio/goquery\n\n`baslikCek` fonksiyonuna URL adresini girdik. Zaten bu fonksiyonu da bi oluşturduk. Hata kontrolü yaptıktan sonra başlıkları yazdırdık.\n\n`baslikCek` fonksiyonuna baktığımızda;\\\nİlk önce url adresini, yani içindeki elementleri, çektik. goquery dökümanına çevirdik. Burada dikkat edilmesi gereken nokta, `resp` değişkeni bizim çektiğimiz url adresidir. Daha sonra liste olarak oluşturduk. Liste oluşturma işleminde `.title` sınıfına ait ve `a` etiketinde olan elementleri sıralamasını istedik. Element seçim işlemi jQuery selector mantığında çalışır.\n\nÇıktımız:\n\n{% hint style=\"info\" %}\nBaşlıklar:\n\n* Announcing the 2019 Go Developer Survey\n* Go.dev: a new hub for Go developers\n* Go Turns 10\n* Go Modules: v2 and Beyond\n* Working with Errors in Go 1.13\n{% endhint %}\n" }, { "path": "boeluem-7-dosya-islemleri/xml-parsing-ayristirma.md", "content": "# XML Parsing (Ayrıştırma)\n\nBu yazımıza Golang üzerinde **XML** dosyalarını işlemeyi öğreneceğiz. Bu işlemin yapabileceğimiz hali hazırda standart Golang paketleri ile gelen **“encoding/xml”** paketi vardır. Örneğimize geçelim.\\\n**veri.xml** isminde aşağıdaki gibi bir belgemiz olduğunu varsayalım.\n\n```markup\n\n<üyeler>\n <üye tip=\"admin\">\n Ahmet\n \n https://facebook.com\n https://twitter.com\n https://youtube.com\n \n \n <üye tip=\"okuyucu\">\n Mehmet\n \n https://facebook.com\n https://twitter.com\n https://youtube.com\n \n \n\n```\n\n**XML Belgemizi Okuyalım**\n\nBu işlemimizi yaparken **“io/ioutil”** ve **“os”** paketlerimizden faydalanacağız. Hemen kodlarımızı görelim.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"os\"\n)\nfunc main() {\n\t// XML dosyamızı açıyoruz\n\txmlDosya, err := os.Open(\"veri.xml\")\n\t// Hata var mı diye kontrol ediyoruz\n\tif err != nil {\n\t\tfmt.Println(err)\n\t}\n\tfmt.Println(\"veri.xml dosyası başarıyla açıldı\")\n\t// XML dosyamızı kapatmayı unutmuyoruz.\n\tdefer xmlDosya.Close()\n}\n```\n\nEğer XML dosyası açılırken hata oluşmazsa çıktımız olumlu yönde olacaktır.\\\nŞimde XML dosyasındaki verileri struct’ımıza kaydedelim. Parsing işlemi de yapacağımızdan dolayı **“encoding/xml”** paketini de içe aktarıyoruz. Hemen kodumuz geliyor.\n\n```go\npackage main\nimport (\n\t\"encoding/xml\"\n\t\"fmt\"\n\t\"io/ioutil\"\n\t\"os\"\n)\ntype Üyeler struct {\n\tAlan xml.Name `xml:\"üyeler\"`\n\tÜyeler []Üye `xml:\"üye\"`\n}\ntype Üye struct {\n\tAlan xml.Name `xml:\"üye\"`\n\tTip string `xml:\"tip,attr\"`\n\tİsim string `xml:\"isim\"`\n\tSosyal Sosyal `xml:\"sosyal\"`\n}\ntype Sosyal struct {\n\tAlan xml.Name `xml:\"sosyal\"`\n\tFacebook string `xml:\"facebook\"`\n\tTwitter string `xml:\"twitter\"`\n\tYoutube string `xml:\"youtube\"`\n}\nfunc main() {\n\t// XML dosyamızı açıyoruz\n\txmlDosya, err := os.Open(\"veri.xml\")\n\t// Hata var mı diye kontrol ediyoruz\n\tif err != nil {\n\t\tfmt.Println(err)\n\t}\n\t// XML dosyamızı kapatmayı unutmuyoruz.\n\tdefer xmlDosya.Close()\n\t//XML dosyamızı okuyoruz (byte olarak geliyor)\n\tbyteDeğer, _ := ioutil.ReadAll(xmlDosya)\n\t//Yerleştirme işlemi için değişken oluşturuyoruz.\n\tvar üyeler Üyeler\n\txml.Unmarshal(byteDeğer, &üyeler)\n\tfmt.Println(üyeler.Üyeler)\n}\n```\n" }, { "path": "cli/cobra-cli.md", "content": "---\ncoverY: 0\n---\n\n# 🐍 Cobra CLI\n\n
\"\"

Cobra CLI logo

\n\nCobra, basit arayüzlü komut satırı uygulamaları oluşturmanız için güçlü bir pakettir. CLI uygulamanızı kolaylıkla oluşturabilmeniz için aynı zamanda oluşturucu bir cli aracıdır.\n\nÖzellikler:\n\n* Kolay alt-komut (subcommand) yapısında cli uygulamaları: `app server` , `app fetch` gibi,\n* Tamamen POSIX uyumlu flag'ler (kısa ve uzun versiyonları ile),\n* İç içe alt-komutlar,\n* Global, yerel ve cascading (basamaklı) flag'ler,\n* `cobra init appname` ve `cobra add cmdname` gibi komutlarla kolayca yapı oluşturma,\n* Akıllı öneriler (`app servr` ... did you mean `app server`?)\n* Komutlar ve flag'ler için otomatik yardım oluşturma\n* Otomatik help flag tanımlaması `-h` ve `--help`\n* Otomatik shell auto-completion oluşturma (bash-zsh-fish-powershell)\n* Otomatik manual sayfası oluşturma\n* Komut alias'ları\n* Kendi yardım ve kullanım bilgilerini tanımlama esnekliği\n\n## Kurulumlar\n\n### Paketi kurmak için;\n\n`go get -u github.com/spf13/cobra@latest`\n\n### CLI aracını kurmak için;\n\n`go install github.com/spf13/cobra@latest`\n\n\n\n## Basit Bir Başlangıç Yapalım\n\nProje klasörümüzü oluşturduktan sonra,\n\n`cobra-cli` aracının çalışması için proje klasörümüzün içerisinde eğer `go modules` kurulmamışsa `go mod init ` komutunu çalıştırmamız gerekiyor.\n\n`cobra-cli init uygulamam` veya bulunduğunuz dizinde oluşturmak için `uygulamam` yerine `.` (nokta) kullanabilirsiniz.\n\nBu komuttan sonra aşağıdaki gibi klasör ve dosya yapısı oluşacaktır.\n\n{% code title=\"\" %}\n```\n.\n├── LICENSE\n├── cmd\n│   └── root.go\n├── go.mod\n├── go.sum\n└── main.go\n\n1 directory, 5 files\n```\n{% endcode %}\n\nOluşturulan yapıyı incelediğimizde, `main.go` dosyamız basitçe aşağıdaki gibi görünür.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport \"cobra-cli-example/cmd\"\n\nfunc main() {\n\tcmd.Execute()\n}\n```\n{% endcode %}\n\nimport kısmındaki `cobra-cli-example`, go module'daki belirlediğimiz isim olduğundan sizde farklı görünecektir. `main()` fonksiyonu içerisinde alt-paketimiz olan `cmd` içerisindeki `Execute()` fonksiyonunu çalıştırıyor. Varsayılan kullanımda tüm flag'ler ve sub-command'ler vs. bu fonksiyonun çalışmasıyla yüklenecek.\n\ncmd klasörünün içerisine baktığımızda, burada `root.go` isimli dosyamızı görüyoruz. Bu dosyamızın içerisinde cli uygulamamız başlatıldığında herhangi bir komut girilmemiş ise gerçekleşecek işlemleri bulundurabiliriz.\n\nÖrnek olarak komut satırı kullanımında;\n\n`./cobra-cli-example`\n\nveya\n\n`go run .`\n\n\n\n`root.go` dosyasını inceleyelim.\n\n{% code title=\"root.go\" %}\n```go\npackage cmd\n\nimport (\n\t\"os\"\n\n\t\"github.com/spf13/cobra\"\n)\n\n\n// rootCmd, uygulama alt-komutsuz şekilde çağırıldığında\n//gerçekleşecekleri temsil eder.\nvar rootCmd = &cobra.Command{\n\tUse: \"cobra-cli-example\",\n\tShort: \"uygulamanın kısa bilgisi\",\n\tLong: `uygulamanın uzun bilgilendirme metnini bu kısma girebilirsiniz.`,\n}\n\n// Execute fonksiyonu tüm komut ve alt-komutları\n// uygulama çalıştırıldığında yüklenmesini sağlar\nfunc Execute() {\n\terr := rootCmd.Execute()\n\tif err != nil {\n\t\tos.Exit(1)\n\t}\n}\n\nfunc init() {\n\t// init fonksiyonu içerisinde ise komuta bağlı olan\n\t// alt-komutlarını ve flag'lerini bağlayabilir ve bunlar\n\t// için özelleştirmelerde bulunabilirsiniz.\n\trootCmd.Flags().BoolP(\"toggle\", \"t\", false, \"toggle için yardım mesajı\")\n}\n```\n{% endcode %}\n\nBu uygulamayı `go run .` komutu ile başlattığınızda, aşağıdaki gibi bir sonuç alırsınız.\n\n{% code title=\"$ go run .\" %}\n```\nuygulamanın uzun bilgilendirme metnini bu kısma girebilirsiniz.\n```\n{% endcode %}\n\nVarsayılan olarak `rootCmd` altındaki `Long` içerisinde yazdığımız açıklama metni görünür.\n\nUygulamamız çalıştığında bir işlem gerçekleştirmek istiyorsak, aşağıdaki gibi yapabiliriz.\n\n`root.go` dosyası içerisinde `rootRun` isminde bir fonsiyon oluşturalım.\n\n{% code title=\"cmd/root.go\" %}\n```go\nfunc rootRun(cmd *cobra.Command, args []string) {\n\tfmt.Println(\"Merhaba Dünya!\")\n}\n```\n{% endcode %}\n\nBu fonksiyonumuzun çalıştırılması için oluşturduğumuz `rootCmd` nesnesine ekleyelim.\n\n{% code title=\"cmd/root.go\" lineNumbers=\"true\" %}\n```go\nvar rootCmd = &cobra.Command{\n\tUse: \"cobra-cli-example\",\n\tShort: \"uygulamanın kısa bilgisi\",\n\tLong: `uygulamanın uzun bilgilendirme metnini bu kısma girebilirsiniz.`,\n\tRun: rootRun,\n}\n```\n{% endcode %}\n\n5\\. satırda `Run` alanına çalıştırmak istediğimiz fonksiyonu yazdık.\n\nUygulamamızı başlattığımızda aşağıdaki gibi bir çıktı ile karşılaşacağız.\n\n{% code title=\"$ go run .\" %}\n```\nMerhaba Dünya!\n```\n{% endcode %}\n\nBöylece `rootCmd` uzun bilgilendirme metnini görüntülemek yerine artık istediğimiz işlemi yapıyor.\n\n\n\nEğer bilgilendirme metnini veya yardım metinlerini görmek istersek, `-- help` veya `-h` flag'lerini kullanabiliriz.\n\n{% code title=\"$ go run . --help\" %}\n```\nuygulamanın uzun bilgilendirme metnini bu kısma girebilirsiniz.\n\nUsage:\n cobra-cli-example [flags]\n\nFlags:\n -h, --help help for cobra-cli-example\n -t, --toggle toggle için yardım mesajı\n\n```\n{% endcode %}\n\n### Uygulamanın yüklenmesi\n\nOluşturduğumuz uygulamayı yüklemek için build edebilir veya `go install` komutu ile yükleyebilirsiniz.\n\n`go install` ile yükledikten sonra komut bulunamıyorsa, `~/go/bin` klasörünü `path`'e eklemeyi deneyebilirsiniz.\n\n### Bir komut ekleyelim\n\nKomut eklemek için tekrardan `cobra-cli` aracından faydalanabiliriz. Bunun için;\n\n{% code title=\"$ cobra-cli add gopher \" %}\n```\ngopher created at /xxxxxxx/cobra-cli-example\n```\n{% endcode %}\n\nBu komut sonrası `cmd` klasörümüzün içerisinde komuta verdiğimiz isim olan `gopher` isminde bir `go` dosyası oluşturulduğunuz göreceksiniz.\n\nBu dosyayı inceleyelim. Aşağıdaki kodlarda sadeleştirilmiş halini göreceksiniz.\n\n{% code title=\"cmd/gopher.go\" %}\n```go\npackage cmd\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/spf13/cobra\"\n)\n\n// gopherCmd, gopher komutunu temsil eder.\nvar gopherCmd = &cobra.Command{\n\tUse: \"gopher\",\n\tShort: \"gopher komutu için kısa tanımlama\",\n\tLong: `gopher komutu için uzun tanımlama metnini buraya girebilirsiniz.`,\n\tRun: func(cmd *cobra.Command, args []string) {\n\t\tfmt.Println(\"gopher komutu çalıştı\")\n\t},\n}\n\nfunc init() {\n\t// Bu kısımda gopher komutumuzun cli üzerinden çağrılabilmesi için\n\t// root komutumuza ekliyoruz.\n\trootCmd.AddCommand(gopherCmd)\n}\n```\n{% endcode %}\n\nYukarıdaki örnekte `run` fonksiyonunu direkt olarak `gopherCmd` içerisinde yazdık. Zaten varsayılan olarak oluşturulduğunda burada yazıyor. Kod düzenini sağlamak için eğer uzun satırlı bir fonksiyon olacaksa ayrı bir yerde yazılması tavsiye edilir.\n\nAşağıdaki komutla bu işlemi de deneyebiliriz.\n\n{% code title=\"$ go run . gopher\" %}\n```\ngopher komutu çalıştı\n```\n{% endcode %}\n\n### Alt-komut ekleme\n\nYukarıdaki gopher komutuna bir alt komut eklemek istersek, aşağıdaki yöntemi uygulamalıyız.\n\nÖncelikle `cobra-cli` aracı üzerinden bir komut ekleyelim.\n\n{% code title=\"$ cobra-cli add alt\" %}\n```\nalt created at /xxxxxxxxx/cobra-cli-example\n```\n{% endcode %}\n\n`cmd` içerisindeki `alt.go` dosyasında yapmamız gereken tek şey hangi komuta alt komut olarak vereceğimizi belirtmektir. Varsayılan olarak eklenen tüm komutlar `rootCmd`'ye eklenir. İstersek bu komutu `gopher` komutuna alt komut olarak ekleyebiliriz. Bunun için `alt.go` dosyasındaki `init()` fonksiyonuna bakabiliriz.\n\n{% code title=\"cmd/alt.go\" %}\n```go\nrootCmd.AddCommand(altCmd) \n```\n{% endcode %}\n\nBu bölümü aşağıdaki gibi değiştirelim.\n\n{% code title=\"cmd/alt.go\" %}\n```go\ngopherCmd.AddCommand(altCmd)\n```\n{% endcode %}\n\nBu değişiklikleri gözlemlemek için aşağıdaki komutu deneyebiliriz.\n\n{% code title=\"$ go run . gopher alt \" %}\n```\nalt called\n```\n{% endcode %}\n\n### Argümanları okuma\n\nArgümanlar komutların yanına girilen, `string` olarak okunabilen değerlerdir.\n\n{% hint style=\"info\" %}\nArgümanları okuyabilmek için kullanacağımız komutun bir alt-komutu olmaması gerekir.\n{% endhint %}\n\nÖrnek olarak `root` komut üzerinden bir argüman okuyalım.\n\n{% code title=\"cmd/root.go\" %}\n```go\nfunc rootRun(cmd *cobra.Command, args []string) {\n\tfmt.Println(\"Merhaba\", args[0], \"!\")\n}\n```\n{% endcode %}\n\nBu yapıya göre aşağıdak şekilde uygulamamızı deneyelim.\n\n{% code title=\"$ go run . Kaan\" %}\n```\nMerhaba Kaan !\n```\n{% endcode %}\n\nEğer `root` komutuna bir alt-komut ekli olsaydı, `Kaan` isimli bir komutun olmadığını gösteren bir hata alacaktık.\n\n{% code title=\"$ go run . Kaan \" %}\n```\nError: unknown command \"Kaan\" for \"cobra-cli-example\"\nRun 'cobra-cli-example --help' for usage.\nexit status 1\n```\n{% endcode %}\n\nBu yüzden argümanlarımızı sadece alt-komut içermeyen komutlar üzerinden okumalıyız.\n\n### Bir flag ekleyelim\n\nFlag'leri kullanarak cli uygulamamızı kullanan kullanıcılara seçenekler sunabiliriz. Bir flag eklemek için birden fazla yöntem vardır. İlke olarak flag'imizde ayarlanacak değeri kaydetmek için bir değişken oluşturalım ve aşağıdaki gibi bir yapı kuralım. Bu flag'imizi `root` komutuna ekleyeceğiz.\n\nDiğer alanlar üzerinden de kullanabilmemiz için değişkenimizi global olarak tanımlayalım.\n\n{% code title=\"cmd/root.go\" %}\n```go\nvar isim string\n```\n{% endcode %}\n\nFlag'i eklemek için `root.go` içerisinde `init()` fonksiyonuna ekleme yapalım.\n\n{% code title=\"cmd/root.go\" %}\n```go\nfunc init() {\n\trootCmd.Flags().StringVarP(&isim, \"isim\", \"i\", \"Ahmet\", \"--isim veya -i \")\n}\n```\n{% endcode %}\n\n`StringVarP()` fonksiyonu ile pointer kullanarak oluşturduğumuz değişkenin adresine komut satırından aldığımız değeri atayabiliriz. Bu flag'i aşağıdaki gibi kullanabiliriz.\n\n`rootCmd`'nin `Run` alanına bağladığımız fonksiyon içerisinde kullanalım.\n\n{% code title=\"cmd/root.go\" %}\n```go\nfunc rootRun(cmd *cobra.Command, args []string) {\n\tfmt.Println(\"Merhaba\",isim,\"!\")\n}\n```\n{% endcode %}\n\nAşağıdaki komut ile uygulamamızı deneyebiliriz.\n\n{% code title=\"$ go run . --isim Kaan\" %}\n```\nMerhaba Kaan !\n```\n{% endcode %}\n\nYukarıdakinden farklı olarak başka kullanım şekilleri de vardır.\n\n`go run . -i Kaan`\n\n`go run . --isim=Kaan`\n\n`go run . --i=Kaan`\n\nAslında gördüğünüz gibi tamamen posix bir cli uygulaması olarak çalışıyor.\n\nEğer `isim` flag'ini belirtmeden başlatılırsa varsayılan değer olarak verdiğimiz \"Ahmet\" kullanılacaktır.\n\nFlag'i ekledikten sonra yardım komutunu çalıştırdığımızda aşağıdaki gibi bir çıktı alırız.\n\n{% code title=\" $ go run . --help\" %}\n```\nuygulamanın uzun bilgilendirme metnini bu kısma girebilirsiniz.\n\nUsage:\n cobra-cli-example [flags]\n cobra-cli-example [command]\n\nAvailable Commands:\n completion Generate the autocompletion script for the specified shell\n gopher gopher komutu için kısa tanımlama\n help Help about any command\n\nFlags:\n -h, --help help for cobra-cli-example\n -i, --isim string --isim veya -i (default \"Ahmet\")\n\nUse \"cobra-cli-example [command] --help\" for more information about a command.\n```\n{% endcode %}\n\nYukarıda gördüğümüz gibi her komut veya flag eklediğimizde bilgilendirmesi yardım alanında görünür.\n\nEğer kullanacağımız flag sadece uzun flag kullanımı içerecekse `StringVar()` fonksiyonunu kullanabiliriz.\n\n```go\nrootCmd.Flags().StringVar(&isim,\"isim\",\"Ahmet\",\"--isim veya -i \")\n```\n\nEğer flag'in bir değer dönmesini istersek, yani işaretçisiz kullanımı için, `String()` fonksiyonunu kullanabiliriz.\n\n```go\nisim := rootCmd.Flags().String(\"isim\", \"Ahmet\", \"--isim veya -i \")\n```\n\nDeğer dönme ile beraber uzun flag ile kullanmak istersek, `StringP()` fonksiyonunu kullanabiliriz.\n\n```go\nisim := rootCmd.Flags().StringP(\"isim\", \"i\", \"Ahmet\", \"--isim veya -i \")\n```\n\nYukarıda gördüğümüz yöntemler ile daha farklı veri tipleri için kullanım senaryoları oluşturabiliriz.\n\nSadece fonksiyon ismindeki `String` yerine kullanmak istediğiniz veri tipini yazmanız yeterlidir.\n\n### Kalıcı (Persistent) flag ekleme\n\nKalıcı flag'ler üst komutlara eklendiğinde alt komutlar üzerinde de kullanılabilir.\n\nAşağıdaki örnekte kalıcı flag'imizi root komuta ekleyip gopher komut üzerinde de kullanmayı göreceğiz.\n\n{% code title=\"cmd/root.go\" %}\n```go\nrootCmd.PersistentFlags().StringVarP(&isim, \"isim\", \"i\", \"Ahmet\", \"--isim veya -i \")\n```\n{% endcode %}\n\nYukarıdaki örnekte flag'in alt komutlar üzerinde de çalışması için, diğer örneklerin aksine `Flags()` yerine `PersistentFlags()` fonksiyonunu kullandık. Uygulamamızı deneyelim.\n\n{% code title=\"$ go run . gopher -i Kaan \" %}\n```\ngopher komutu çalıştı\n```\n{% endcode %}\n\nBöylelikle `isim` flag'inden gelen değeri de okuyabildik. Bu yöntem dışında yapıldığında, flag'in geçersiz olduğuna dair hata verecektir.\n\n### Flag'i zorunlu kılma\n\nBir komut altındaki bir flag'i zorunlu kılmak için `MarkFlagRequired()` fonksiyonunu kullanabiliriz.\n\n{% code title=\"root.go\" %}\n```go\nrootCmd.Flags().StringVar(&isim, \"isim\", \"Ahmet\", \"--isim veya -i \")\nerr := rootCmd.MarkFlagRequired(\"isim\")\nif err != nil {\n log.Fatalln(err)\n}\n```\n{% endcode %}\n\nUygulamamızı `isim` flag'ini girmeden başlattığımızda aşağıdaki gibi bir hata alacağız.\n\n{% code title=\"$ go run .\" %}\n```\nError: required flag(s) \"isim\" not set\n```\n{% endcode %}\n\n### Versiyon belirtme\n\nUygulamanın `--version` flag'i ile versiyonunun gösterilmesi için, `rootCmd` nesnesi tanımlanırken `Version` alanı içerisine versiyonu bildiren bir numara yazabiliriz. Örnek olarak:\n\n{% code title=\"cmd/root.go\" lineNumbers=\"true\" %}\n```go\nvar rootCmd = &cobra.Command{\n\tUse: \"cobra-cli-example\",\n\tShort: \"uygulamanın kısa bilgisi\",\n\tLong: `uygulamanın uzun bilgilendirme metnini bu kısma girebilirsiniz.`,\n\tRun: rootRun,\n\tVersion: \"0.1\",\n}\n```\n{% endcode %}\n\n6\\. satırda uygulamanın versiyonunu belirttik. Uygulama üzerinde deneyelim.\n\n{% code title=\"$ go run . --version\" %}\n```\ncobra-cli-example version 0.1\n```\n{% endcode %}\n\n### Kullanımdan kaldırılan (Deprecated) komutlar\n\nUygulamamızda kullanılan bir alt komutu, yani `root` olmayan diğer komutları, kaldırmak yerine bu komutların eskide kaldığını kullancılara bildirebiliriz. Bunun için kullanımdan kaldıracağımız komutu aşağıdaki gibi bir ekleme yapabiliriz.\n\n{% code title=\"cmd/alt.go\" %}\n```go\nvar altCmd = &cobra.Command{\n\tUse: \"alt\",\n\tShort: \"kısa tanım\",\n\tLong: `uzun tanım`,\n\tRun: func(cmd *cobra.Command, args []string) {\n\t\tfmt.Println(\"alt çalıştırıldı\")\n\t},\n\tDeprecated: \"[altyeni] komutunu kullanın\",\n}\n```\n{% endcode %}\n\n`Depracated` alanına string tipinde bir açıklama yapabiliriz. `Deprecated` komutlar çalışmaya devam eder. Uygulamamızı deneyelim.\n\n{% code title=\"$ go run . alt\" %}\n```\nCommand \"alt\" is deprecated, [altyeni] komutunu kullanın\nalt çalıştırıldı\n```\n{% endcode %}\n" }, { "path": "gui/notify-bildirim.md", "content": "# notify (Bildirim)\n\nBazen programımızda kullanıcının haberdar olması için bildirim özelliği gerekir. Bu özelliği `notify` paketi ile kazandırabiliriz.\n\n> go get github.com/martinlindhe/notify\n\nPaketi indirdikten sonra, aşağıdaki kodları deneyebilirsiniz.\n\n```go\npackage main\n\nimport \"github.com/martinlindhe/notify\"\n\nfunc main() {\n\t// Bildirim Gösterme\n\tnotify.Notify(\"Uygulama İsmi\", \"Başlık\", \"Açıklama\", \"icon/yolu.png\")\n\n\t// Sesli Bilgirim Gösterme\n\tnotify.Alert(\"Uygulama İsmi\", \"Başlık\", \"Açıklama\", \"icon/yolu.png\")\n}\n```\n\n![GNU/Linux (Ubuntu'da)](../.gitbook/assets/linux.png)\n\n![macOS / OSX 10.8+](<../.gitbook/assets/macos (1).png>)\n\n![Windows 10](<../.gitbook/assets/windows (1).png>)\n" }, { "path": "gui/webview.md", "content": "# WebView\n\n**webview** kütüphanesine giriş yapmadan önce bahsetmek istediğim birkaç konu var.\\\nDaha önce aramızda **electron.js**‘i duyanlar olmuştur. Hani şu Visual Studio Code, Skype, Atom, Discord ve Slack gibi başarılı uygulamaların yazılmış olduğu Javascript kütüphanesinden bahsediyorum. Electron.js ile yazılan uygulamalar **HTML**, **CSS** ve **Javascript**‘in gücüyle kaliteli bir grafiksel kullanıcı arayüzüne ulaşabiliyor. Eğer bir Web Developer’sanız kolayca masaüstü uygulaması yazabiliyorsunuz. Ama Electron.js ile yazılmış uygulamaların kötü yanları da var tabi. Uygulama boyutu bunlardan en sıkıntılı olanı. En basit bir uygulamanın boyutu 150 Megabyte olabiliyor. Bir de **electron-packager** yardımı ile uygulama build edilirken uzun süre bekliyorsunuz.\\\nŞimdi gelelim bizi bu olaylardan kurtaracak olan gözümün nuru Golang Kütüphanesi olan **webview** kütüphanesine ♥\n\n**webview** kütüphanesi **zserge** arkadaşımız tarafından yazılmış olan, web sayfaları tasarlayıp programa dönüştürebildiğimiz, backend kısmını Golang rahatlığında yazdığımız bir kütüphane (veya paket)dir. \n\n{% hint style=\"info\" %}\nzserge/webview repo'su webview/webview'a taşınmıştır.\n{% endhint %}\n\nBuild işlemi sonrası aslında elimizde bir internet tarayıcısı olmuş oluyor. Bu tarayıcı üzerinden hazırlamış olduğumuz web sayfası görüntüleniyor. Frontend ve Backend arasındaki iletişimi ise **Bind** ile sağlıyoruz. Bu özelliği birazdan kodlar içerisinde açıklayacağım.\n\nSadece **Windows**, **GNU/Linux** ve **macOS** için uygulama geliştirebiliyoruz.\\\nGNU/Linux üzerinde **gtk-webkit2**, macOS üzerinde **Cocoa/Webkit** ve Windows üzerinde **Edge** alt yapısını kullanıyor. Linux üzerinde çalışması için, gtk-webkit2 paketini yüklemeyi unutmayın. Bu detaylara bakacak olursak, Windows üzerinde çalışırken Edge Browser’ı kullanacak. macOS ve GNU/Linux üzerinde ise Chrome benzeri bir altyapı kullanacak. Bu durumda GNU/Linux ve macOS için geliştirmek daha mantıklı çünkü daha fazla görsel efekt imkanı var olacaktır. Örnek: CSS3’teki **-webkit-** etiketi…\\\nGelelim kütüphanenin kurulumuna. Aşağıdaki komut ile kütüphanemizi indiriyoruz.\n\n> go get github.com/webview/webview\n\n\n\nKütüphanemizi kurduğumuza göre ufak bir örnek görelim. Daha sonra detaylı örnekler göstereceğim.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\n//webview paketimizi içe aktaralım\nimport \"github.com/webview/webview\"\n\nfunc main() {\n\t//debug değişkeninde debug modu açıyoruz.\n\tdebug := true\n\t\n\t//yeni webview nesnesi oluşturduk.\n\tpencere := webview.New(debug)\n\t\n\t//main fonksiyonunun sonunda pencerenin sonlanmasını\n\t//istedik.\n\tdefer pencere.Destroy()\n\t\n\t//pencere başlığımızı belirttik.\n\tpencere.SetTitle(\"kaanksc.com\")\n\t\n\t//penceremizin boyutunu belirttik.\n\t//(genişlik, uzunluk)\n\tpencere.SetSize(800, 600, webview.HintNone)\n\t//webview.HintNone ile normal bir pencere oluşturduk.\n\t\n\t//penceremizin yükleyeceği adresi belirtelim.\n\tpencere.Navigate(\"https://kaanksc.com\")\n\t\n\t//son olarak penceremizi başlatalım.\n\tpencere.Run()\n}\n```\n{% endcode %}\n\n![Oluşturulan pencerenin görünümü](../.gitbook/assets/Screenshot\\_20201012\\_130620.png)\n\nYukarıdaki gibi basit bir yöntem ile bir **gui** program oluşturabiliyorsunuz. Seviyeyi biraz yükseltelim ve sonraki örneğimize geçelim.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\n\t\"github.com/webview/webview\"\n)\n\n//anasayfayı yakalaması için bir yakalayıcı oluşturuyoruz.\nfunc handler(w http.ResponseWriter, r *http.Request) {\n\t//anasayfada gösterilecek metnimiz.\n\tfmt.Fprintf(w, \"Uygulamaya hoşgeldiniz!\")\n}\n\n//sunucu oluşturan fonksiyonumuz.\nfunc serverOlustur() {\n\t// anasayfanın handler fonksiyonu ile çalışmasını.\n\t//istiyoruz\n\thttp.HandleFunc(\"/\", handler)\n\n\t//sunucumuzun koşacağı portu belirtiyoruz.\n\thttp.ListenAndServe(\":5555\", nil)\n}\nfunc main() {\n\t//webview penceremize eşzamanlı olarak sunucunun\n\t//koşturulmasını istiyoruz.\n\tgo serverOlustur()\n\n\t//webview nesnesi oluşturuyoruz.\n\tpencere := webview.New(true)\n\t// New fonksiyonundaki true ifadesi debug modunda\n\t//çalışmasını sağlıyor. Sayfaya sağ tıklayarak\n\t//görebilirsiniz.\n\n\t//main fonksiyonun son işlemi olarak webview\n\t//penceresinin kaldırılmasını istiyoruz.\n\tdefer pencere.Destroy()\n\n\t//penceremizin başlığını belirtiyoruz.\n\tpencere.SetTitle(\"Uygulamam\")\n\n\t//penceremizin boyutunu belirtiyoruz.\n\tpencere.SetSize(400, 300, webview.HintNone)\n\n\t//hangi adresi yükleyeceğini belirtiyoruz.\n\tpencere.Navigate(\"http://localhost:5555\")\n\n\t//son olarak penceremizi başlatıyoruz.\n\tpencere.Run()\n}\n\n```\n{% endcode %}\n\nHemen açıklamasını yapayım. Kendi sunucumuzu oluşturmak için **“net/http”** kütüphanesini ekledik. **serverOlustur()** fonksiyonunda klasik web server oluşturmak için gerekli kodları yazdık. Görüntülenecek içeriği **handler()** fonksiyonunda belirttik.\\\n**main()** fonksiyonu içerisindeki kodlarımıza geçelim. **serverOlustur()** fonksiyonunu **Goroutine** ile yazmazsak web server ayağa kaldırıldığında (açıldığında) kapanana kadar alt taraftaki webview kodlarının çalışmasına sıra gelmez. Başına **go** ekleyerek aynı anda server’ın oluşturulmasına ve diğer kodların çalışmasını sağlıyoruz. **webview** kodlarımızda ise oluşturduğumuz web server’ın bilgilerini ve pencere ayarlarını giriyoruz.\\\nBiraz değişiklikler ile istediğimiz bir klasörü göstermeye ayarlayabiliriz.\n\nProjemizin yapısı aşağıdaki gibi olsun.\n\n{% code title=\"Proje yapımız\" %}\n```bash\n.\n├── klasor\n│ └── index.html\n└── main.go\n```\n{% endcode %}\n\n**index.html** dosyamız aşağıdaki gibi olsun.\n\n{% code title=\"index.html\" %}\n```markup\n\n\n\n \n Bu kısma aslında gerek yok\n\n\n

Merhaba Dünya!

\n\n\n```\n{% endcode %}\n\n**main.go** dosyamız ise aşağıdaki gibi olsun.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/webview/webview\"\n)\n\n//sunucu başlatan fonksiyonumuz\n//aslında bunu main fonksiyonuna da\n// \"go http.ListenAndServe(\":5555\", nil)\"\n//şeklinde yazabilirsiniz.\nfunc serverOlustur() {\n\t//dinlecek portu belirttik (5555)\n\thttp.ListenAndServe(\":5555\", nil)\n}\nfunc main() {\n\t//Sunucumuzun hangi klasörden oluşacağını\n\t//belirtiyoruz. (klasor isimli klasörümüzden)\n\tklasor := http.FileServer(http.Dir(\"klasor/\"))\n\n\t//anasayfayı klasor'e bağlayalım.\n\thttp.Handle(\"/\", http.StripPrefix(\"/\", klasor))\n\n\t//eşzamanlı olarak sunucuyu başlatalım.\n\tgo serverOlustur()\n\n\t//debug açık şekilde webview nesnesi oluşturalım.\n\tpencere := webview.New(true)\n\n\t//pencere başlığını girelim.\n\tpencere.SetTitle(\"Uygulamam\")\n\n\t//pencere boyutunu ve normal pencere olacağını belirtelim.\n\tpencere.SetSize(600, 400, webview.HintNone)\n\n\t//Yukarıda başlattığımız sunucunun adresini girelim.\n\tpencere.Navigate(\"http://localhost:5555\")\n\n\t//penceremizi başlatalım.\n\tpencere.Run()\n}\n```\n{% endcode %}\n\nSıra geldi Backend (Golang) ve Frontend (Javascript) arasındaki iletişimi sağlamaya. Aşağıdaki işlemleri yukarıdaki klasör yapısında göre yapacağız. Yani bu şekilde:\n\n{% code title=\"Proje yapımız\" %}\n```bash\n.\n├── klasor\n│ └── index.html\n└── main.go\n```\n{% endcode %}\n\n## **Frontend’den Backend’e Veri Gönderme (JavaScript ===> Go)**\n\nBu işlemi gerçekleştirebilmemiz için webview tarayıcısının frontend’deki sinyalleri dinlemesi gerekir. Golang tarafından dinlemek için **Bind()** fonksiyonunu kullanıyoruz.\n\nÖrnek bir **main.go** dosyası oluşturalım.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\n\t\"github.com/webview/webview\"\n)\n\nfunc serverOlustur() {\n\thttp.ListenAndServe(\":5555\", nil)\n}\nfunc main() {\n\tklasor := http.FileServer(http.Dir(\"klasor/\"))\n\thttp.Handle(\"/\", http.StripPrefix(\"/\", klasor))\n\tgo serverOlustur()\n\tpencere := webview.New(true)\n\tpencere.SetTitle(\"Uygulamam\")\n\tpencere.SetSize(600, 400, webview.HintNone)\n\tpencere.Navigate(\"http://localhost:5555\")\n\n\t//Bind fonksiyonu ile dinleyici oluşturduk\n\tpencere.Bind(\"merhaba\", func(isim string) {\n\t\t//Javascript'teki merhaba fonksiyonunu dinliyoruz.\n\t\t//Javascript'teki bu fonksiyona string bir değer girilecek.\n\t\t//Bu değeri de aşağıdaki gibi ekrana bastıracağız.\n\t\tfmt.Println(\"merhaba\", isim)\n\t})\n\tpencere.Run()\n}\n```\n{% endcode %}\n\n`Bind()` fonksiyonunu `pencere.Run()`'dan önce yazmalıyız. Eğer sonra yazarsak, çalışma zamanı `Run()` fonksiyonu kapatılmadan `Bind()` fonksiyonuna gelmeyeceği için yazmamızın bir mantığı olmaz.\n\nSıra geldi websayfamızdaki kodları yazmaya.\n\nklasor klasörümüzün içerisine **uygulama.js** dosyası oluşturalım.\n\n{% code title=\"Proje yapımız\" %}\n```bash\n.\n├── klasor\n│ ├── index.html\n│ └── uygulama.js << burada\n└── main.go\n```\n{% endcode %}\n\n**index.html** dosyamıza ise bir yazı kutusu ve buton ekleyelim.\n\nEk olarak da **uygulama.js** dosyamızı html etiketi olarak ekleyelim.\n\n{% code title=\"index.html\" %}\n```markup\n\n\n\n \n Bu kısma aslında gerek yok\n\n\n

Merhaba Dünya!


\n \n \n \n\n\n```\n{% endcode %}\n\nOluşturduğumuz HTML elementlerine id'ler vererek, bunları Javascript'te kullanacağız.\n\n**uygulama.js** dosyamızun içeriği ise aşağıdaki gibi olsun.\n\n{% code title=\"uygulama.js\" %}\n```javascript\nvar yaziKutusu = document.querySelector(\"#isim\")\n//yazı kutusunun id'sini belirttik\n\nvar gonderButonu = document.querySelector(\"#gonder\")\n//Gönder butonunun id'sini belirttik\n\n//Gönder butonuna tıklandığı zaman gerçekleşecek olaylar\ngonderButonu.addEventListener(\"click\",() => {\n //yazı kutusunun içindeki değeri isim değişkeni olarak belirledik.\n var isim = yaziKutusu.value;\n //merhaba fonksiyonuna isim değişkeninin değerini yolladık.\n merhaba(isim)\n //Farkettiyseniz javascript tarafında merhaba adında bir fonksiyon\n //oluşturmadık. Normalde tarayıcı buna hata verecektir.\n //Ama biz golang tarafındaki webview'e merhaba fonksiyonunu bildirdik\n //ve dinleyici olarak tanıttık. \n})\n```\n{% endcode %}\n\nBu işlemler sonucunda uygulamamızı projemizin ana dizinindeyken `go run .` şeklinde başlatalım.\n\n**Yazı kutusu**na isim girip **Gönder** butonuna baştığımızda konsol tarafında `merhaba isim` şeklinde bir çıktı görürüz.\n\n## **Backend’den Frontend’e Veri Gönderme (Go ===> JavaScript)**\n\nAslında burada yapacağımız olay bir JavaScript kodu çalıştırmak veya tetiklemek de denebilir. Tıpkı Developer Console'dan yaptığımız gibi..\n\nBu işlem için `Eval()` fonksiyonundan faydalanıyoruz. Örnek için yukarıdaki kodlarımıza devam edelim.\n\n`merhaba` fonksiyonunu dinliyoruz demiştik. `Bind()` içerisinde komut satırına isim bastırmak yerine JavaScript konsoluna ismi bastıralım.\n\n`Bind()` fonksiyonumuzun içeriği şöyle olsun.\n\n```go\npencere.Bind(\"merhaba\", func(isim string) {\n //Eval ile gönderilecek js kodumuzu oluşturalım.\n jsKodumuz := fmt.Sprintf(\"console.log('Merhaba, %s!')\", isim)\n //isim değişkeni %s yerinde gösterilecek.\n pencere.Eval(jsKodumuz)\n})\n```\n\nUygulamamızı çalıştırıp yazı kutusuna bir isim girdiğimizde Komut satırından şöyle bir çıktı alabiliriz:\n\n> [http://localhost:5555/:1:12](http://localhost:5555/:1:12): CONSOLE LOG Merhaba, Kaan!\n\nİsterseniz Webview içerisindeki Developer Tool ile de bakabiliriz.\n\nSayfaya sağ tıklayalım ve Inspect Element'e tıklayalım. Açılan bölümde **Console** sekmesine geçelim. All şeçeneğinin şeçili olduğundan emin olalım. Ve işte! log çıktımızın burada.\n\n![Developer Tool görünümü](../.gitbook/assets/jskonsole.png)\n\nBu işlemler ile kolay bir şekilde Backend-Frontend arası iletişimi sağlayabilirsiniz.\n\n## Golang ile Webview'a Asenkron Müdahale Etme\n\nGo tarafında asenkron işlemler için **Goroutine**'leri kullandığımızı belirtmiştik. Backend tarafında zaman alan bir işlemi goroutine ile asenkron bir işlem parçacığı haline getirmezsek. İşlem tamamlanana kadar webview penceremiz yanıt vermez. Yani herhangi bir şeye tıklayamayız. Bu yüzden uzun sürecek arkaplan işlemlerini **Webview**'e aseknron şekilde çalıştırmamız gerekir.\n\nÖrnek bir `Bind()` fonksiyonunda aseknron bir işlemi inceleyelim.\n\n```go\npencere.Bind(\"merhaba\", func(isim string) {\n\t\t//asenkron çalışan bir anonim fonksiyon oluşturalım\n\t\tgo func(){\n\t\t\t//3 saniye beklesin\n\t\t\ttime.Sleep(3*time.Second)\n\t\t\t//ve ekrana JavaScript tarafından gelen\n\t\t\t//isim değişkenini bastırsın.\n\t\t\tfmt.Println(isim)\n\t\t}()\n})\n```\n\nYukarıdaki örnekte JavaScript tarafından çalıştırılacak merhaba fonksiyonunu dinliyoruz. Bu fonksiyon bize string tipinde bir değer iletiyor. Asenkron olarak anonim bir fonksiyon oluşturuyoruz ve içeriğinde 3 saniye beklemesini istiyoruz. Son olarak ekrana isim değişkenindeki değeri bastırıyoruz.\n\nEğer bu kodları asenkron olarak çalıştırmasaydık, Webview penceremiz 3 saniye boyunca yaptığımız hiçbir işleme tepki vermeyecekti.\n\nŞimdi buraya kadar karışık bir olay yok aslında. Asıl asenkron mantığı 3 saniye bekleyip çıktımızı JavaScript konsoluna bastırmak olacaktır. Aralarındaki asenkron olayı bu şekilde sağlancaktır.\n\nNormalde asenkron iki işlemin birinden diğerine ait olan bir işlemi yapmak için işaretçileri _(pointer)_ kullanabiliriz. Fakat Webview nesnesine bir işaretçi atayamayız. Çünkü webview ile oluşturulan nesnemiz bir interface'tir.\n\nÖrnek bir deneme girişimi 😀\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"time\"\n\n\t\"github.com/webview/webview\"\n)\n\nfunc serverOlustur() {\n\thttp.ListenAndServe(\":5555\", nil)\n}\nfunc main() {\n\tklasor := http.FileServer(http.Dir(\"klasor/\"))\n\thttp.Handle(\"/\", http.StripPrefix(\"/\", klasor))\n\tgo serverOlustur()\n\tpencere := webview.New(true)\n\tpencere.SetTitle(\"Uygulamam\")\n\tpencere.SetSize(600, 400, webview.HintNone)\n\tpencere.Navigate(\"http://localhost:5555\")\n\n\tpencere.Bind(\"merhaba\", func(isim string) {\n\t\t//fonksiyonumuzu asenkron olarak başlatıyoruz\n\t\tgo fonksiyonumuz(&pencere, isim)\n\t\t//parametre olarak pencere nesnesinin adresini verdik\n\t\t//aynı şekilde isim değişkenini de\n\t})\n\tpencere.Run()\n}\n\nfunc fonksiyonumuz(p *webview.WebView, isim string) {\n\t//3 saniye beklemesini istedik\n\ttime.Sleep(3 * time.Second)\n\t//Eval ile gönderilecek JS kodumuzu hazırlayalım\n\tjsKodumuz := fmt.Sprintf(\"alert('%s')\", isim)\n\n\t//İşte geldik Zurnanın zırt dediği yere (kullandığım deyime takılmayın 😀)\n\tp.Eval(jsKodumuz)\n\t//Bu kısımda böyle bir kullanım yapamayacağımızı söylüyor olacak.\n}\n```\n{% endcode %}\n\n![Hata mesajı](../.gitbook/assets/pointeryanlış.png)\n\nŞuana kadar gösterdiğim şeyler bir yanlış yapmayın diyeydi. Yukarıdaki yöntemi doğru değildir. Doğrusu `Dispatch()` fonksiyonunu kullanmaktır. Go kodlarımızın tamamını görecek şekilde bir örnek verelim. Örnek kullanımı:\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"time\"\n\n\t\"github.com/webview/webview\"\n)\n\nfunc serverOlustur() {\n\thttp.ListenAndServe(\":5555\", nil)\n}\nfunc main() {\n\tklasor := http.FileServer(http.Dir(\"klasor/\"))\n\thttp.Handle(\"/\", http.StripPrefix(\"/\", klasor))\n\tgo serverOlustur()\n\tpencere := webview.New(true)\n\tpencere.SetTitle(\"Uygulamam\")\n\tpencere.SetSize(600, 400, webview.HintNone)\n\tpencere.Navigate(\"http://localhost:5555\")\n\n\tpencere.Bind(\"merhaba\", func(isim string) {\n\t\t//fonksiyonumuzu asenkron olarak başlatıyoruz\n\t\tgo fonksiyonumuz(pencere, isim)\n\t\t//parametre olarak pencere nesnesini & olmadan verdik\n\t})\n\tpencere.Run()\n}\n\nfunc fonksiyonumuz(p webview.WebView, isim string) {\n\t//3 saniye beklemesini istedik\n\ttime.Sleep(3 * time.Second)\n\t//Eval ile gönderilecek JS kodumuzu hazırlayalım\n\tjsKodumuz := fmt.Sprintf(\"alert('%s')\", isim)\n\n\t//Dispatch fonksiyonu ile ana iş parçacığındaki webview\n\t//nesnesi ile işlem yapabiliriz.\n\tp.Dispatch(func() {\n\t\tp.Eval(jsKodumuz)\n\t})\n}\n```\n{% endcode %}\n\n## Webview Kütüphanesindeki Diğer Fonksiyonlar\n\n### Destroy()\n\nWebview penceremizi sonlandırır.\n\n```go\npencere.Destroy()\n```\n\n### Terminate()\n\nPencerenin çalışmasını keser.\n\n```go\npencere.Terminate()\n```\n\n### Eval()\n\nPencerede JavaScript kodu çalıştırmamızı sağlar.\n\n```go\npencere.Eval(\"alert('Merhaba!')\")\n```\n\n### Init()\n\nPencereye JavaScript kodu iliştirir. `Eval()` fonksiyonundan farkı ise sayfa değişse bile JavaScript kodu sayfada kalır. `Eval()` ile bir kere mahsus JavaScript kodu çalıştırılır. `Init()` fonksiyonunda sayfa yenilenince bile kod çalışırır.\n\n```go\npencere.Init(\"alert('Merhaba!')\")\n```\n\n### Navigate()\n\nWebview penceresinin belirtilen adresi yüklemesini sağlar.\n\n```go\npencere.Navigate(\"https://www.google.com.tr\")\n```\n\n### Run()\n\nPencereyi başlatır.\n\n```go\npencere.Run()\n```\n\n### SetSize()\n\nPencerenin boyutunu ve etkileşimini ayarlar.\n\n```go\n//Genişlik, Uzunluk, Etkileşim\npencere.SetSize(800, 600, webview.HintNone)\n//webview.HintNone ile normal,\n//webview.HintFixed ile boyutu değiştirilemeyen,\n//webview.HintMax ile en fazla solundaki büyüklükte,\n//webview.HintMin ile en az solundaki küçüklükte\n//bir pencere oluşturabiliriz.\n```\n\n### SetTitle()\n\nPencerenin başlığını değiştirmemizi sağlar.\n\n```go\npencere.SetTitle(\"Uygulama Başlığım\")\n```\n\n" }, { "path": "kitap-hakkinda/katkida-bulunanlar.md", "content": "---\ndescription: Değerli vaktini ayırıp, dökümanın geliştirilmesine katkıda bulunan kişiler\n---\n\n# Katkıda Bulunanlar\n\n\\*Liste harf sıralamasına göre yapılmıştır.\n\n| PP | Kişi | Github |\n| ----------------------------------------------------------------------------------------------------------------- | -------------------- | --------------------------------------------------- |\n| \"\" | Adem Ali Durmuş | [@ademalidurmus](https://github.com/ademalidurmus) |\n| \"\" | Adem İlter | [@ademilter](https://github.com/ademilter) |\n| \"\" | Aykut Kardaş | [@aykutkardas](https://github.com/aykutkardas) |\n| \"\" | Berkay Çoban | [@berkaycoban](https://github.com/berkaycoban) |\n| \"\" | Emre Önal | [@emmreonal](https://github.com/emmreonal) |\n| \"\" | Erhan Yakut | [@yakuter](https://github.com/yakuter) |\n| \"\" | Hazarek | [@hazerek](https://github.com/hazarek) |\n| \"\" | Latif Uluman | [@latif70427517](https://twitter.com/latif70427517) |\n| \"\" | Mert Şimşek | [@mertingen](https://github.com/mertingen) |\n| \"\" | Murat Mirgün Ercan | [@muratmirgun](https://github.com/muratmirgun) |\n| \"\" | Yunus Emre Geldegül | [@emregeldegul](https://github.com/emregeldegul) |\n| \"\" | Yusuf Dündar | [@yusufdundar](https://github.com/yusufdundar) |\n| \"\" | Yusuf Turhan Papurcu | [@yusufpapurcu](https://github.com/yusufpapurcu) |\n" }, { "path": "mikro-denetleyiciler/gobot-ile-arduino-yanip-soenen-led-yapimi.md", "content": "# Gobot ile Arduino Yanıp-Sönen LED Yapımı\n\nBu yazımda sizlere Golang için Robotik kütüphanesi olan **Gobot**‘tan bir örnek göstereceğim. Bu örneğimizde Arduino’da yanıp sönen LED yapacağız.\\\nİlk olarak Gobot kütüphanesini indiriyoruz.\n\n> go get -d -u gobot.io/x/gobot/...\n\nDaha sonra Arduino’muzla iletişim kurabilmemiz için **Gort**‘u yüklememiz gerekiyor.\\\n[https://gort.io/documentation/getting\\_started/downloads/](https://gort.io/documentation/getting\\_started/downloads/)\\\nBu örnekte **Arduino Uno** kullanacağız. Arduino’muzun bilgisayarımıza bağlıyoruz ve hangi porta bağlı olduğunu öğrenmek için komut satırına aşağıdakileri yazıyoruz.\n\n> gort scan serial\n\nWindows’ta **\\** benzeri, Linux’ta ise **/dev/ttyUSB\\*** benzeri bir çıktı verecektir. Bu bizim Arduino’muzun bağlı olduğu portu gösteriyor.\\\nAşağıdaki kodlar yanıp sönen LED için yazılmıştır. Kodları gördükten sonra açıklamasını yapacağım.\n\n```go\npackage main\nimport (\n \"time\"\n \"gobot.io/x/gobot\"\n \"gobot.io/x/gobot/drivers/gpio\"\n \"gobot.io/x/gobot/platforms/firmata\"\n)\nfunc main() {\n firmataAdaptor := firmata.NewAdaptor(\"/dev/ttyUSB0\")\n led := gpio.NewLedDriver(firmataAdaptor, \"13\")\n work := func() {\n gobot.Every(2*time.Second, func() {\n led.Toggle()\n })\n }\n robot := gobot.NewRobot(\"bot\",\n []gobot.Connection{firmataAdaptor},\n []gobot.Device{led},\n work,\n )\n robot.Start()\n}\n```\n\nAçıklamasına gelirsek;\\\nGobot ile alakalı kütüphanelerimizi ekliyoruz. **firmataAdaptor** değişkenimizde Arduino’muzun portunu yazıyoruz. Ben Linux kullandığım için Linux’taki portunu yazdım. **led** değişkenimizde ledimizin **13**. dijital pinde yer aldığını belirttik. Yani LED’imizin artı ucunu **13. pine** eksi ucunu ise **GND** (Ground-Toprak-Nötr) girişine bağlayacağız.\n\nSıra geldi çalışma fonksiyonumuz olan **work**‘e. **work** değişkenine anonim bir fonksiyon tanımladık. Bu fonksiyonda **led.Toggle()** fonksiyonu ile her **2** saniyede yanıp-sönmesini ayarladık. En sondaki **robot** değişkeninde ise firmataAdaptor değişkenimizdeki Arduino portuyla bağlantı kurmasını ve hemen altında **led** değişkenini cihaz olarak tanıttık. Son olarak **work** değişkenindeki olayları gerçekleştirip, **robot.Start()** fonksiyonu ile çalışmasını sağladık.\\\nYukarıda gördüğünüz üzere **Firmata** kelimesini kullandık. Firmata bizim Arduino cihazımız ile iletişimde bulunabilmemizi sağlayan bir yazılım. Yukarıdaki kodlarımızın çalışması için Arduino’muz içerisine Firmata yazılımını yüklememiz gerekir. Onu da yüklemesi aşağıdaki gibi çok kolay bir işlem.\n\n> gort arduino upload firmata /dev/ttyUSB0\n\n**/dev/ttyUSB0** yerine kendi Arduino portunuzu yazmayı unutmayın.\\\nUygulamamızı başlatmak için ise aşağıdakileri yazıyoruz.\n\n> go run main.go\n\n**main.go** yerine ne isim verdiyseniz onu yazınız.\n" }, { "path": "mikro-denetleyiciler/tinygo-ile-kuecuek-yerler-icin-golang.md", "content": "# Tinygo ile Küçük Yerler için Golang\n\n![Tinygo Logosu](../.gitbook/assets/tinygo-logo.png)\n\nTinygo, Golang kodları ile mikro-denetleyicilere program yazmamızı sağlayan bir derleyicidir.\n\nAynı zamanda yazdığımız kodları mikro-denetleyicinin beynine flash eder. Flash etme kelimesinden kastım, beyne çalışacak kodları yazdırmaktır.\n\n{% content-ref url=\"gobot-ile-arduino-yanip-soenen-led-yapimi.md\" %}\n[gobot-ile-arduino-yanip-soenen-led-yapimi.md](gobot-ile-arduino-yanip-soenen-led-yapimi.md)\n{% endcontent-ref %}\n\nGobot ile Arduino Yanıp-Sönen LED Yapımı konusunda bahsettiğim. Gobot paketinden farkı, Gobot Firmata yazılımını Arduino’ya gömdükten sonra Arduino’ya çalıştırılabilir komutlar yolluyor. Yani kodlarımızı Arduino içine gömmediğinden, sadece Arduino USB veya TCP ile bağlı olduğundan çalışıyor.\n\nFakat Tinygo, Golang kodlarımızı Arduino’nun içerisine gömüyor. Bu sebeble Arduino’nun kodlarımızı çalıştırması için sadece bir elektrik kaynağına bağlı olması yetiyor.\n\n**Gelelim Kuruluma**\n\n### GNU/Linux\n\nUbuntu/DebianBirinci Adım:\\\n`wget https://github.com/tinygo-org/tinygo/releases/download/v0.9.0/tinygo_0.9.0_amd64.deb`\\\nİkinci Adım:\\\n`sudo dpkg -i tinygo_0.9.0_amd64.deb`\\\nÜçüncü Adım:\\\n`export PATH=$PATH:/usr/local/tinygo/bin`RaspBerry PiBirinci Adım:\\\n`wget https://github.com/tinygo-org/tinygo/releases/download/v0.9.0/tinygo_0.9.0_armhf.deb`\\\nİkinci Adım:\\\n`sudo dpkg -i tinygo_0.9.0_armhf.deb`\\\nÜçüncü Adım:\\\n`export PATH=$PATH:/usr/local/tinygo/bin`Arch LinuxAUR deposundan [tinygo-bin](https://aur.archlinux.org/packages/tinygo-bin/) olarak aratabilirsiniz.Fedora Linux`sudo dnf install tinygo`\n\n### **Windows**\n\nÖncelikle şuanda Windows üzerinde deneme aşamasında olduğunu söylemeliyim.\n\nİlk olarak LLVM 8’i kurmalısınız.\n\n[Buradan indirme sayfasına gidebilirsiniz.](http://releases.llvm.org/download.html#8.0.1)\n\nLLVM 8 kurulumu esnasında “LLVM’yi ortam değişkenlerine ekle” seçeneğini seçmeyi unutmayın.\n\nDaha sonra Tinygo arşiv dosyasını indirelim.\n\n[Tinygo Arşiv Dosyası İndir](https://github.com/tinygo-org/tinygo/releases/download/v0.9.0/tinygo0.9.0.windows-amd64.zip)\n\nAşağıdaki komut ile Tinygo’yu kuralım.\n\n`PowerShell Expand-Archive -Path \"c:\\Downloads\\tinygo0.9.0.windows-amd64.zip\" -DestinationPath \"c:\\tinygo\"`\n\nAşağıdaki komut ile Tinygo’yu ortam değişkenlerine ekleyelim.\n\n`set PATH=%PATH%;C:\\tinygo\\bin;`\n\n### MacOS\n\nİlk adım:\n\n​`brew tap tinygo-org/tools`\n\nİkinci Adım:\n\n`brew install tinygo`\n\n### Kurulum Sonrası\n\nKurulum işlemlerimiz tamamlandıktan sonra kontrol etme amaçlı komut satırına aşağıdaki komutları yazalım.\n\n`tinygo version`\n\nKullandığınız işletim sistemine göre fark göstermekle birlikte aşapıdakine benzer bir çıktı alacaksınız.\n\n`tinygo version 0.9.0 linux/amd64 (using go version go1.12.9)`\n\nBu işlemler sırasında elimde bulunan Arduino Uno kartı ile işlemler yapacağımız belirteyim. Diğer kartlar ile arasında çok bir işlem farkı bulunmamaktadır. Aynı veya benzer yollardan sizce bu işlemleri gerçekleştirebilirsiniz.\n\nÖncelikle Arduino Uno kartımızın hangi USB portuna bağlı olduğunu bulalım.\n\nWindows üzerinden **COM3** benzeri bir portta takılıdır. İnternet üzerinden detaylı araştırma yapabilirsiniz.\n\nUnix-like sistemlerde (Linux, MacOS) ise genelde **/dev/ttyUSB** veya **/dev/ttyACM** portarından birinde takılı olabilir. Arduino’nun bağlı olduğu portu `ls /dev/ttyUSB*` komutu ile öğrenebilirsiniz.\n\nBen Arduino Uno kartımın **/dev/ttyUSB0** üzerinde olduğu için aşağıdaki işlemlerimi ona göre yapacağım. Kullandığım komutları kendi portunuza göre değiştirmeyi unutmayın.\n\nAşağıda Arduino UNO üzerindeki Built-In LED’i saniyede bir yanıp-söndürmeye yarayan Golang kodları yer alıyor.\n\n```go\npackage main\n\nimport (\n\t\"machine\"\n\t\"time\"\n)\n\nfunc main() {\n\tled := machine.LED\n\tled.Configure(machine.PinConfig{Mode: machine.PinOutput})\n\tfor {\n\t\tled.Low()\n\t\ttime.Sleep(time.Millisecond * 1000)\n\n\t\tled.High()\n\t\ttime.Sleep(time.Millisecond * 1000)\n\t}\n}\n```\n\nDosyamızın ismini main.go yapalım. Yukarıdaki Golang kodlarımızı kaydettikten sonra komut satırını main.go dosyasının bir üst klasöründe açalım.\n\nGo kodlarımızı Arduino üzerine yazdırmak için aşağıdaki komutları kullanalım.\n\n`tinygo flash -target=arduino -port=/dev/ttyUSB0 ./kodumuzunbulunduğuklasör`\n\nGördüğünüz gibi Tinygo ile flash etme işlemi çok basit.\n" }, { "path": "pratik-bilgiler/derleme-build-detayini-goerme.md", "content": "# Derleme (Build) Detayını Görme\n\nGolang’de normalde derleme işlemini yapmak için go build komutunu kullanırız. Bu komut terminal ekranından bize sadece bir hata olduğunda bilgi verir. Hata yoksa çalıştırılabilir dosyayı zaten oluşturur.\\\n \n\n**Peki programımızın derlenme esnasında bilgilendirmeyi nasıl görebiliriz?**\n\nİşte aşağıdaki gibi:\n\n> go build -gcflags=-m main.go\n\nYani build’e ek parametre olarak **-gcflags=-m** yazıyoruz. Nasıl gözüktüğünü örnek olarak görelim.\n\n```go\npackage main\nimport (\n \"fmt\"\n \"os\"\n)\nfunc main() {\n fmt.Println(\"Merhaba\")\n fmt.Println(topla(2,2))\n os.Exit(0)\n}\nfunc topla(x,y int) int{\n return x + y\n}\n```\n\nYukarıdaki kodumuzun derleme çıktısı şöyle olacaktır.\n\n> command-line-arguments\\\n> ./main.go:13:6: can inline topla\\\n> ./main.go:9:13: inlining call to fmt.Println\\\n> ./main.go:10:22: inlining call to topla\\\n> ./main.go:10:16: inlining call to fmt.Println\\\n> ./main.go:9:14: \"Merhaba\" escapes to heap\\\n> ./main.go:9:13: io.Writer(os.Stdout) escapes to heap\\\n> ./main.go:10:16: io.Writer(os.Stdout) escapes to heap\\\n> ./main.go:10:22: topla(2, 2) escapes to heap\\\n> ./main.go:9:13: main \\[]interface {} literal does not escape\\\n> ./main.go:10:16: main \\[]interface {} literal does not escape\\\n> :1: os.(\\*File).close .this does not escape\n" }, { "path": "pratik-bilgiler/dinamik-degiskenler.md", "content": "# Dinamik Değişkenler\n\nDaha önceki bölümlerden de gördüğümüz üzere Go, dinamik atamayı desteklemiyor. Ama bunun elbette bir yöntemi var. Bunun için `interface`'den faydalanabiliriz.\n\nÖrnek:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n)\n\n//dinamik atama yapabilmek için önce boş bir interface oluşturalım\ntype dynamic interface{}\n\nfunc main() {\n\n\t//x değişkenimizin tipini interface olarak belirleyelim\n\tvar x dynamic\n\n\t//x'e integer tipinde değer atayalım\n\tx = 13\n\n\t//x'in tipini ve değerini ekrana bastıralım\n\tfmt.Printf(\"%T:%v\\n\", x, x) //int:13\n\n\t//Daha sonradan x'e string tipinde değer atayalım\n\tx = \"selam\"\n\n\t//x'in tipini ve değerini ekrana bastıralım.\n\tfmt.Printf(\"%T:%q\\n\", x, x) //string:\"selam\"\n}\n```\n\nYukarıdaki örnekte görüldüğü üzere `x` değişkenimize hangi tipte atama yaparsak, `x` değerin tipine dönüşüyor.\n\n### Any\n\nGo'ya gelen güncellemeden sonra `interface{}` yazmak yerine `any` yazarsanız aynı işlemi görür.\n\n```go\nvar degisken any\n```\n" }, { "path": "pratik-bilgiler/go-gelistiricileri-icin-makefile.md", "content": "# Go Geliştiricileri için Makefile\n\nGolang ile yazılım geliştirirken **Makefile** teknolojisinde nasıl faydalanacağımızı göreceğiz. Gözümüzün korkmasına gerek yok, aşırı basit bir olay. Zaten herşeyi biliyorsunuz. Makefile sadece bir yöntemdir.\\\n \n\n**Makefile Nedir?**\n\n**Makefile**, çoğu komutu çalıştırmak için kullanabileceğimiz otomasyon aracıdır. Makefile’ı genellikle Github veya Gitlab’de programların ana dizininde bazı işlemleri otomatikleştirme için kullanıldığını görebilirsiniz.\\\n \n\n**Basit Bir Örnek**\n\nBir proje klasörü oluşturalım ve bu klasörün içine **makefile** adında dosya oluşturalım. Daha sonra makefile dosyamızı herhangi bir editör ile açalım ve içerisine aşağıdakileri yazalım.\n\n```python\nmerhaba:\n echo \"merhaba\"\n```\n\nGördüğünüz gibi programlama dillerine ve komutlara benzer bir yazılımı var.\\\nKodumuzu **make** komutu ile deneyebiliriz. Proje klasörümüzün içerisinde komut satırına **make merhaba** yazarak kodumuzun çıktısını görelim:\n\n> echo \"Merhaba\"\\\n> Merhaba\n\nGördüğünüz gibi **make** komutunun yanına **merhaba** ekleyerek **makefile** dosyamızdaki merhaba bölümünün çalışmasını sağladık. Makefile’ın genel mantığına baktığımızda komut satırı üzerinden yaptığımız işlemleri kısaltıyor.\\\n \n\n**Basit Go Uygulaması İnşa Etme**\n\n```go\npackage main\nimport \"fmt\"\nfunc main() {\n\tfmt.Println(\"Merhaba\")\n}\n```\n\nYukarıda gördüğünüz gibi basit bir Go uygulamamız var. Şimdi bu Go dosyamız ile işlem yapabilmek için **makefile** dosyamıza komutlar girelim.\n\n```python\nmerhaba:\n\techo \"Merhaba\"\nbuild:\n\tgo build main.go\nrun:\n\tgo run main.go\n```\n\nYukarıda gördüğünüz gibi **makefile** dosyamıza bloklar açarak bildiğiniz komut satırı komutlarını girdik. Yukarıdaki kodların durumuna göre **make build** ile Go dosyamızı build ederiz ve **make run** ile Go dosyamızı çalıştırırız. Gayet basit bir mantığı var.\n\n**Peki bu olay bizim ne işimize yarayacak?**\n\nÖrneğin bir projeyi 3 tane platform için build etmemiz gerekecek. Her platform için ayrı Go Ortamı bilgisi girmemiz gerekir. Hele ki build işlemini sürekli yapıyorsanız bu işten bıkabilirsiniz. Fakat makefile dosyasıyla işinizi kolaylaştırabilirsiniz.\\\nÖrneğimizi görelim:\n\n```python\nderle:\n\techo \"Windows, Linux ve MacOS için Derleme İşlemi\"\n\tGOOS=windows GOARCH=amd64 go build -o bin/main-windows64.exe main.go\n\tGOOS=linux GOARCH=amd64 go build -o bin/main-linux64 main.go\n\tGOOS=darwin GOARCH=amd64 go build -o bin/main-macos64 main.go\nrun:\n\tgo run main.go\nhepsi: derle run\n```\n\n**derle** bloğumuzun içerisine 3 platforma derlemek için komutlarımızı girdik. **run** bloğuna ise **main.go** dosyamızı çalıştırmak için komutumuzu girdik. **hepsi** bloğunun yanına ise **derle** ve **run** yazdık. Yani komut satırına **make hepsi** yazarsak hem derleme hem de çalıştırma işlemini yapacak.\\\n \\\nBu yazımızda **Golang için** **makefile** kullanımına örnek verdik. İlla ki Go’da kullanılacak diye bir kaide yok. Diğer programlama dillerinde veya komutlarınızı otomatize etmek istediğiniz zaman kullanabilirsiniz.\n" }, { "path": "pratik-bilgiler/isletim-sistemini-goerme.md", "content": "# İşletim Sistemini Görme\n\nGo programının çalıştığı işletim sistemi görmek için aşağıdaki kodları yazabilirsiniz.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nfunc main() {\n\n\tif r := runtime.GOOS; r == \"windows\" {\n\t\tfmt.Println(\"Windows için yönerici olarak çalıştırın.\")\n\t} else if r == \"linux\" {\n\t\tfmt.Println(\"Linux için sudo komutu ile çalıştırın.\")\n\t} else {\n\t\tfmt.Println(\"Geçersiz işletim sistemi!\")\n\t}\n}\n```\n\nGNU/Linux kullandığım için çıktım aşağıdaki gibi olacaktır.\n\n> Linux için sudo komutu ile çalıştırın.\n\n" }, { "path": "pratik-bilgiler/visual-studio-code-icin-golang-oezellestirmeleri.md", "content": "# Visual Studio Code için Golang Özelleştirmeleri\n\nBu yazıda Visual Studio Code üzerinde Golang için kullanabileceğimiz özelleştirmelerden bahsedeceğiz. Bu özelleştirmeler sayeseinde kod yazma deneyimimizi iyileştirebiliriz.\n\n## Canlı Hata Ayıklama\n\nVSCode üzerinde Go dili kodları yazarken farketmişsinizdir. Kodu yazarken hata ayıklamıyor. Sadece dosyayı kaydettiğimizde hata ayıklama işlemi yapıyor. Kod üzerinde canlı hata ayıklamayı aktif etmemiz gerekiyor. Bunun için;\n\n`CTRL + SHIFT + P` tuşlarına beraber basarak, VSCode komut bölümünü açalım. Bu kısma `\"Preferences: Open User Settings\"` yazalım ve çıkan ilk sonuca girelim.\n\n![Adım.1](../.gitbook/assets/prefer.png)\n\nAçılan `Settings` sekmesinde üst tarafta bulunan arama yapma kutusuna `\"Go: Live Errors\"` yazalım. Çıkan sonuçta `\"Edit in settings.json\"` bağlantısına tıklayalım.\n\n![Adım.2](../.gitbook/assets/prefer2.png)\n\n```javascript\n\"go.liveErrors\": {\n \"enabled\": false, //Burayı true yapalım.\n \"delay\": 500 //tepki süresi\n}\n```\n\nAçılan editörde `\"go.liveErrors\"` anahtarının karşısında ayarlarımız var. `\"enabled\"` anahtarının değerini `true` yapalım. `\"delay\"` anahtarındaki değerde ise yazdıktan kaç milisaniye sonra hata ayıklama yapacağını belirtiyoruz. `500` (yarım saniye) normal bir değerdir.\n\nDaha sonra bir `.go` dosyası oluşturalım veya hali hazırda `.go` dosyasını açalım. Açtığımız dosyanın içerisine birşeyler yazmaya çalıştığımızda VSCode'un sağ alt köşesinde bir uyarı verecektir. Bu uyarıda **Install** butonuna tıklayarak eklenti yükleme işlemini başlatalım. Bu eklenti canlı hata ayıklama yapmak için gereklidir. Yüklendiğinde **Output** sekmesinde aşağıdakine benzer bir sonuç alacaksınız.\n\n> Tools environment: GOPATH=C:\\Users\\kaank\\go Installing 1 tool at C:\\Users\\kaank\\go\\bin in module mode. gotype-live\\\n> \\\n> Installing github.com/tylerb/gotype-live (C:\\Users\\kaank\\go\\bin\\gotype-live.exe) SUCCEEDED\\\n> \\\n> All tools successfully installed. You are ready to Go :).\n\nArtık canlı hata ayıklama özelliğini kullanabilirsiniz.\n\n![Canlı Hata Ayıklama](../.gitbook/assets/livedebug.gif)\n\n## Go Yazarken Kullanabileceğiniz VSCode Eklentileri\n\n### ErrorLens\n\nBu eklenti ile kod yazarken eğer hata varsa alakalı satırın sağında hata mesajını görebilirsiniz. Bu eklentiyi Go için kullanmadan önce Go için canlı hata ayıklamayı açmanızı tavsiye ederim _(Yukarıda gösterdim)_.\n\n![ErrorLens Eklentisi](../.gitbook/assets/errorlens.png)\n\n### Better Comments\n\nYorum satırlarını daha şık gösteren bir eklentidir. Tavsiye ederim. Satırın başına koyduğunuz işaret veya yazdığınız yazıya göre satırın rengi değişiyor.\n\n![Better Comments Eklentisi](../.gitbook/assets/bc.png)\n\n\n\n" }, { "path": "veritabani/gorm.md", "content": "# GORM\n\n**Gorm** kütüphanesi sql kullanımını kolaylaştıran ve az kod ile çok iş yapabileceğiniz bir kütüphanedir. **Gorm** kütüphanesini yüklemek için komut satırına aşağıdakileri yazın.\n\n```\ngo get -u gorm.io/gorm\n```\n\n#### Gorm Özellikleri\n\n* Tam Özellikli ORM\n* Hooks (oluşturma/kaydetme/güncelleme/silme/bulmadan önce/sonra)\n* Preload, Joins ile istekli yükleme\n* İşlemler, İç İçe İşlemler, Kaydetme Noktası, Kaydedilen Noktaya Geri Dönme\n* Bağlam, Hazırlanan İfade Modu, DryRun Modu\n* Toplu Ekleme, FindInBatches, Map ile Bul/Oluştur, SQL Expr ve Context Valuer ile CRUD\n* SQL Builder, Upsert, Locking, Optimizer/Index/Comment İpuçları, Adlandırılmış Bağımsız Değişken, Alt Sorgu\n* Bileşik Birincil Anahtar, Dizinler, Kısıtlamalar\n* Otomatik Taşıma\n* Genişletilebilir, esnek eklenti API: Database Resolver (birden çok veritabanı, okuma/yazma bölme) / Prometheus…\n* Geliştirici Dostu\n\nGorm kütüphanesini kullanabilmemiz için bir sql dili seçmemiz gerekmektedir. Bu öğreticide sqlite kullanacağız. Sqlite kütüphanesini yüklemek için komut satırına aşağıdakileri yazın.\n\n```\ngo get -u gorm.io/driver/sqlite\n```\n\n### **Gorm Kütüphanesinin Kullanımı**\n\n`main.go` dosyamızı oluşturalım. Kütüphanelerimizi import edelim.\n\n{% code title=\"main.go\" %}\n```go\nimport (\n\t\"fmt\"\n\t\"gorm.io/driver/sqlite\"\n\t\"gorm.io/gorm\"\n)\n```\n{% endcode %}\n\n`\"gorm.io/gorm\"` kütüphanesi ile gorm fonksiyonlarına erişiyoruz. Gorm ile sqlite entegrasyonunu sağlamak için ise \"gorm.io/driver/sqlite\" kütüphanesini kullanıyoruz bu kütüphane kullandığını sql diline göre değişiklik göstermektedir. Şimdi basit şekilde veri tabanı bağlantısı ve crud işlemleri nasıl yapılır görelim.\n\nGorm da manuel olarak tablo oluşturmanız gorm işleyişine tersdir. Bunun yerine bir struct oluşturacağız ve struct içerisine deki özelliklere göre gorm otomatik tablo oluşturacaktır. Struct otomatik tablo çıktı almak için struct içerisinde en üste `gorm.Model` eklentisini eklememiz gerekmektedir.\n\n```go\ntype User struct {\n\tgorm.Model\n\tUsername string `gorm:\"not null;size:30\"`\n}\n```\n\n`sqlite` **'a** bağlanmak için bizden bir veritabanı adı istiyor bu veritabanını kendi otomatik oluşturacaktır;\n\n```go\ndb, _ := gorm.Open(sqlite.Open(\"data.db\"), &gorm.Config{})\n```\n\nOluşturmuş olduğumuz struct ile `AutoMigrate()` fonksiyonunu kullanarak tablo oluşturalım. `Create()` fonksiyonu ile oluşturulan tablomuzun içerisine bir `name` ekleyelim.\n\n{% code title=\"main.go\" %}\n```go\nfunc main() {\n\tdb, _ := gorm.Open(sqlite.Open(\"veri.db\"), &gorm.Config{})\n \tdefer db.Close()\n\tdb.AutoMigrate(&User{}) // Tablo oluşturma\n\t\n\tdb.Create(&User{Username: \"eren\"}) // Tablo içerisine insert\n}\n```\n{% endcode %}\n\nSqlite tablomuz aşağıdaki şekilde gözükmelidir. Gorm otomatik olarak oluşturma, güncelleme ve silinme tarihlerini belirten sütunlar eklemektedir.\n\n
\"\"

Tablo görünümü

\n\nTablomuza bir veri daha ekleyelim tablo içerisinde **id** ile arama yapabilmek için `First()` fonksiyonunu kullanacağız sonucu terminalden alalım.\n\n```\nfunc main() {\n\tdb, _ := gorm.Open(sqlite.Open(\"veri.db\"), &gorm.Config{})\n \tdefer db.Close()\n\tdb.AutoMigrate(&User{}) // oluşturma\n\n\tdb.Create(&User{Username: \"furkan\"}) //ekleme\n\n\tvar users User \n\tdb.First(&users, 2) // id 2 olan kullanıcı getirilecektir.\n\tfmt.Println(users)\n}\n```\n" }, { "path": "veritabani/mongodb.md", "content": "---\ndescription: Twitter @YusihCano\n---\n\n# MongoDB\n\n**MongoDB** 2009 yılında geliştirilmiş açık kaynak kodlu bir NoSQL veritabanıdır. Şimdi Go ile MongoDB veritabanını kullanmak için `mongo-driver` paketini indirelim.\n\n> go get go.mongodb.org/mongo-driver/mongo\n\nKodu sürekli tekrardan yapıştırmamak için import edilecek tüm kütüphaneler burada :\n\n```go\npackage main\n\nimport (\n \"context\"\n \"log\"\n \"time\"\n\n \"go.mongodb.org/mongo-driver/bson\"\n \"go.mongodb.org/mongo-driver/bson/primitive\"\n \"go.mongodb.org/mongo-driver/mongo\"\n \"go.mongodb.org/mongo-driver/mongo/options\"\n)\n```\n\nŞimdi de `database` ile bağlantıyı sağlayalım. Eğer database adresini bilmiyorsanız mongo konsolunuzun nereye bağlandığına bakarak database adresini bulabilirsiniz.\n\n```go\ndatabaseURL := \"mongodb://127.0.0.1:27017\"\nctx, _ := context.WithTimeout(context.Background(), 10*time.Second)\nclient, err := mongo.Connect(ctx, options.Client().ApplyURI(databaseURL))\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\nkisiler := client.Database(\"test\").Collection(\"kisiler\")\n```\n\nBu kısım `main` fonksiyonununun başlangıcı. Kısaca yapılan ise ilk satırda database adresini verdik. Ardından 10 saniye timeout'u olan bir context açtık. Context ve database adresini kullanarak bağlantımızı gerçekleştirdik.Son satırda da istedigimiz veritabanı ve collection'u çektik. Bundan sonra isim adında bir struct oluşturalım. Kişinin ismini ve yaşını tutsun.\n\n```go\ntype Kisi struct {\n ID primitive.ObjectID `bson:\"_id,omitempty\" json:\"id,omitempty\"`\n Isim string `bson:\"isim,omitempty\" json:\"isim,omitempty\"`\n Yas int `bson:\"yas,omitempty\"json:\"yas,omitempty\"`\n}\n```\n\nŞimdi de bir kişi oluşturup database'e ekleyelim.\n\n```go\nbirisi := Kisi{\n Isim: \"Ahmet\",\n Yas: 42,\n}\nres, err := kisiler.InsertOne(context.TODO(), birisi)\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\n\nid := res.InsertedID\nfmt.Println(id)\n```\n\nKişi oluşturma ve ekleme işlemlerinden sonra eklenen verinin id'sini de yazdırdık. MongoDB Compass ya da konsol üzerinden `db.kisiler.find()` yaparak eklenen veriyi görebiliriz. Şimdi de veri okuma yapalım. Tüm verileri almak için :\n\n```go\nctx, _ = context.WithTimeout(context.Background(), 30*time.Second)\ncur, err := kisiler.Find(ctx, bson.D{})\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\ndefer cur.Close(ctx)\nvar list []Kisi\nfor cur.Next(ctx) {\n var result Kisi\n err := cur.Decode(&result)\n if err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n }\n list = append(list, result)\n}\nif err := cur.Err(); err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\nfmt.Println(list)\n```\n\nŞimdi de her hangi bir özelliğe göre arama yapalım.\n\n```go\nvar result Kisi\nctx, _ = context.WithTimeout(context.Background(), 5*time.Second)\nerr = kisiler.FindOne(ctx, bson.M{\"yas\": 42}).Decode(&result)\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\nout, err := json.Marshal(&result)\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\nfmt.Println(string(out))\n```\n\nSilme işlemi yapalım.\n\n```go\nctx, _ = context.WithTimeout(context.Background(), 5*time.Second) // Context for Delete\n_, err = kisiler.DeleteOne(ctx, bson.D{{\"yas\", 39}}) // Delete User\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\n```\n\nİsterseniz başka bir değer üzerinden de silme işlemi yapabilirsiniz. Ben direk istenen veriyi silmek için id kullanmanızı tavsiye ediyorum. Şimdi de Update ile temel fonksiyonları bitirelim.\n\n```go\ndegisecek := Kisi{\n Isim: \"Kemal\",\n Yas: 39,\n}\nyeni := Kisi{\n Isim: \"Kemal\",\n Yas: 100,\n}\nvar filtre bson.M\nbytes, err := bson.Marshal(degisecek)\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\nbson.Unmarshal(bytes, &filtre)\nvar usr bson.M\nbytes, err = bson.Marshal(yeni)\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\nbson.Unmarshal(bytes, &usr)\nupdate := bson.D{\n {\"$set\", usr},\n}\nctx, _ = context.WithTimeout(context.Background(), 5*time.Second)\n_, err = kisiler.UpdateOne(ctx, filtre, update)\nif err != nil {\n log.Fatal(\"Hata : \" + err.Error())\n}\n```\n" }, { "path": "veritabani/mysql.md", "content": "# MySQL\n\n**MYSQL**, bir ilişkisel veritabanı yönetim sistemidir. MySQL yönetimi için kullanacağımız kütüphanenin adı **Go-MySQL-Driver**. Kütüphanemizi aşağıdaki gibi komut satırına yazarak indirelim.\n\n> go get -u github.com/go-sql-driver/mysql\n\nMySQL paketlerimizi import edelim.\n\n```go\nimport \"database/sql\"\nimport _ \"go-sql-driver/mysql\"\n```\n\n**MySQL Bağlantısını Yapma**\\\nDaha sonra **main()** fonksiyonumuz içerisinde MySQL bağlantımızı yapalım.\n\n```go\npackage main\nimport \"database/sql\"\nimport _ \"go-sql-driver/mysql\"\nfunc main(){\n\tdb, err := sql.Open(\"mysql\", \"kullanici:sifre@(127.0.0.1:3306)/vtismi?parseTime=true\")\n\terr := db.Ping()\n}\n```\n\n**db** adındaki fonksiyonel değişkenimize MySQL veritabanı bağlantı bilgilerimizi girdik. **kullanici** yeri MySQL kullanıcı adınızı, **sifre** yerine MySQL şifrenizi, **127.0.0.1:3306** yerine MySQL sunucunuzu e **vtismi** yerine de Veritabanı isminizi yazmayı unutmayın.\\\nDaha sonra veritabanı bağlantı bilgilerimizi doğrulanmak için **db.Ping()** fonksiyonu ile bağlantı denemesi yolluyoruz. Bir hata ile karşılaşıldığında **err** değişkeninin içine hata çıktısını kaydedecektir.\\\nKolaylık olsun diye **main()** fonksiyonu dışına hata çıktılarını kontrol eden bir fonksiyon yazalım.\n\n```go\nfunc kontrol(hata error){\n if hata != nil{\n log.Fatal(hata)\n }\n}\n```\n\nEğer hata çıktısı almak istemiyorsanız. **err** değişkeni yerine **\\_ (alt tire)** koyabilirsiniz. Aynen şu şekilde:\n\n```go\ndb, _ := sql.Open(\"mysql\", \"kullanici:sifre@(127.0.0.1:3306)/vtismi?parseTime=true\")\n```\n\n**İlk Tabloyu Oluşturma**\\\nTablomuz şu şekilde olacak;\\\n\n\n| id | kullanici | sifre | tarih |\n| -- | --------- | ----- | ------------------- |\n| 1 | kaan | 1234 | 2019-08-10 12:30:00 |\n\nBöyle bir tablo yapısını oluşturmak için aşağıdaki sorguyu çalıştırmamız gerekir.\n\n```sql\nCREATE TABLE kullanicilar (\n id INT AUTO_INCREMENT,\n kullanici TEXT NOT NULL,\n sifre TEXT NOT NULL,\n tarih DATETIME,\n PRIMARY KEY (id)\n);\n```\n\nBu sorguyu Golang tarafında yapmak istersek aşağıdaki gibi yazabiliriz.\n\n```go\nsorgu := `\n CREATE TABLE kullanicilar (\n id INT AUTO_INCREMENT,\n kullanici TEXT NOT NULL,\n şifre TEXT NOT NULL,\n tarih DATETIME,\n PRIMARY KEY (id)\n );`\n//Sorguyu çalıştırma\n_, err := db.Exec(sorgu)\n```\n\nBu işlemle birlikte MySQL veritabanımızda **kullanicilar** adında bir tablomuz oluşacaktır.\\\n**Tabloya Veri Girme**\n\n```go\nkullaniciDegeri := \"johndoe\"\nsifreDegeri := \"secret\"\ntarihDegeri := time.Now()\nsonuc, err := db.Exec(`INSERT INTO kullanicilar (kullanici, sifre, tarih) VALUES (?, ?, ?)`, kullaniciDegeri, sifreDegeri, tarihDegeri)\nkullaniciID, err := sonuc.LastInsertId()\nfmt.Println(\"Eklenen kullanıcının id'si:\", kullaniciID)\n```\n\n**Tabloya Sorgu Yapma**\n\n```go\n//Tabloyu sorgulayıp sonuçları değişkenlere yazdıralım\nsorgu:= `SELECT id, kullanici, sifre, tarih FROM kullanicilar WHERE id = ?`\nerr := db.QueryRow(sorgu, sorguid).Scan(&id, &kullanici, &sifre, &tarih)\n//Çıkan aldığımız verileri ekrana bastıralım\nfmt.Println(id, kulanici, sifre, tarih)\n```\n\n**Tablodaki Tüm Verileri Sıralama**\n\n```go\nvar (\n id int\n kullanici string\n sifre string\n tarih time.Time\n)\ntablo, _ := db.Query(`SELECT id, kullanici, sifre, tarih FROM kullanicilar`)\ndefer tablo.Close() //tabloyu kapamayı unutmuyoruz\nfor tablo.Next() {\n err := tablo.Scan(&id, &kullanici, &sifre, &tarih)\n kontrol(err)\n fmt.Println(id, kullanici, sifre, tarih) //kullaniciyi ekrana bastır\n}\nerr := tablo.Err()\nkontrol(err)\n```\n\nEğer tablodaki verileri ekrana bastırmak yerine bir **diziye** (array) kaydetmek istiyorsak aşağıdaki gibi yapabiliriz.\n\n```go\ntype kullanici struct {\n id int\n kullanici string\n sifre string\n tarih time.Time\n}\ntablo, _ := db.Query(`SELECT id, kullanici, sifre, tarih FROM kullanicilar`)\ndefer rows.Close()\nvar kullanicilar []kullanici\nfor tablo.Next() {\n var k kullanici\n err := tablo.Scan(&k.id, &k.kullanici, &k.sifre, &k.tarih)\n kontrol(err)\n kullanicilar = append(kullanicilar, k)\n}\nerr := tablo.Err()\nkontrol(err)\n```\n\nBu işlemin sonucunda kullanicilar dizimiz şu şekilde olacaktır.\n\n```jsx\nkullanicilar {\n kullanici {\n id: 1,\n kullanici: \"ahmet\",\n sifre: \"1234\",\n tarih: time.Time{wall: 0x0, ext: 63701044325, loc: (*time.Location)(nil)},\n },\n kullanici {\n id: 2,\n kullanici: \"mehmet\",\n sifre: \"5678\",\n tarih: time.Time{wall: 0x0, ext: 63701044622, loc: (*time.Location)(nil)},\n },\n}\n```\n\n**Tablodan Satır Silme**\n\n```go\nsilineceksatir := 1\n_, err := vt.Exec(`DELETE FROM kullanicilar WHERE id = ?`, silineceksatir)\nkontrol(err)\n```\n\nGördüğünüz gibi basit bir şekilde MySQL paketi ile veritabanı yönetimi yapabiliyoruz.\\\n**Hepsi Bir Arada**\n\n```go\npackage main\nimport (\n\t\"database/sql\"\n\t\"fmt\"\n\t\"log\"\n\t\"time\"\n\t_ \"github.com/go-sql-driver/mysql\"\n)\nfunc kontrol(err error) {\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n}\nfunc main() {\n\tvt, err := sql.Open(\"mysql\", \"kullanici:sifre@(127.0.0.1:3306)/vtismi?parseTime=true\")\n\tif err := db.Ping(); err != nil {\n\t\tkontrol(err)\n\t}\n\t{ // Yeni tablo oluştur\n\t\tsorgu := `\n CREATE TABLE kullanicilar (\n id INT AUTO_INCREMENT,\n kullanici TEXT NOT NULL,\n sifre TEXT NOT NULL,\n tarih DATETIME,\n PRIMARY KEY (id)\n );`\n\t\t_, err := db.Exec(sorgu)\n\t\tkontrol(err)\n\t}\n\t{ // Yeni kayıt ekle\n\t\tkullanici := \"kaan\"\n\t\tsifre := \"1234\"\n\t\ttarih := time.Now()\n\t\tsonuc, err := db.Exec(`INSERT INTO kullanicilar (kullanici, sifre, tarih) VALUES (?, ?, ?)`, username, password, createdAt)\n\t\tkontrol(err)\n\t\teklenenid, err := sonuc.LastInsertId()\n\t\tfmt.Println(eklenenid)\n\t}\n\t{ // İstenilen kaydı sorgulama\n\t\tvar (\n\t\t\tid int\n\t\t\tkullanici string\n\t\t\tsifre string\n\t\t\ttarih time.Time\n\t\t\tsorguid int = 1\n\t\t)\n\t\tsorgu := \"SELECT id, kullanici, sifre, tarih FROM kullanici WHERE id = ?\"\n\t\terr := vt.QueryRow(sorgu, sorguid).Scan(&id, &kullanici, &sifre, &tarih)\n\t\tkontrol(err)\n\t\tfmt.Println(id, kullanici, sifre, tarih)\n\t}\n\t{ // Tün kayıtları sorgula\n\t\ttype kullanici struct {\n\t\t\tid int\n\t\t\tkullanici string\n\t\t\tsifre string\n\t\t\ttarih time.Time\n\t\t}\n\t\ttablo, err := vt.Query(`SELECT id, kullanici, sifre, tarih FROM kullanicilar`)\n\t\tkontrol(err)\n\t\tdefer tablo.Close()\n\t\tvar kullanicilar []kullanici\n\t\tfor tablo.Next() {\n\t\t\tvar k kullanici\n\t\t\terr := tablo.Scan(&k.id, &k.kullanici, &k.sifre, &k.tarih)\n\t\t\tkontrol(err)\n\t\t\tkullanici = append(kullanicilar, k)\n\t\t}\n\t\terr := rows.Err()\n\t\tkontrol(err)\n\t\tfmt.Printf(\"%#v\", kullanicilar)\n\t}\n\t//Kayıt Sil\n\t{\n\t\tsilinecekid := 1\n\t\t_, err := vt.Exec(`DELETE FROM kullanicilar WHERE id = ?`, silinecekid)\n\t\tkontrol(err)\n\t}\n}\n```\n" }, { "path": "veritabani/sqlite3.md", "content": "# sqlite3\n\n**sqlite3** kütüphanesi kullanımı kolay ve birkaç aşama ile işlerinizi yapabileceğiniz bir kütüphanedir. **sqlite3** kütüphanesini yüklemek için komut satırına aşağıdakileri yazın.\n\n> go get github.com/mattn/go-sqlite3\n\nTablo oluşturma ve düzenleme işlemlerinde bize kolaylık sağlaması için **DB Browser** programına ihtiyacımız olacak. Böylece hızlı bir şekilde veri tabanı olaylarına geçiş yapmış olacağız.\\\n**DB Browser** programını aşağıdaki adresten indirebilirsiniz.\\\n[https://sqlitebrowser.org/dl/](https://sqlitebrowser.org/dl/)\\\nLinux sistemlerin çoğunda **uygulama deposunda** bulunan bir uygulamadır.\n\n![DB Browser ikonu](../.gitbook/assets/dbbrowser.png)\n\nProgramımızı açıp sol üst taraftan **Yeni Veritabanı**’na tıklayalım.\n\n![](../.gitbook/assets/uEIcZ3.webp)\n\nVeritabanının kayıt yerini, programımızın kodlarının bulunacağı **main.go** dosyası ile aynı yeri seçelim ve ismini **veritabanı.db** olarak kaydedelim. İstediğiniz ismi de verebilirsiniz.\n\n![](../.gitbook/assets/88iU5v.webp)\n\nTablomuzun ismini **kisiler** olarak ayarlayalım. **Alan Ekle**’ye tıklayarak yukarıdaki gibi **id** ve **ad** isminde alanlar oluşturalım. **id** alanının tipini **INTEGER** yaparak, sayısal verileri saklayabilmesini sağlıyoruz. **Birincil Anahtar** ve **Otomatik Arttırma** bölümlerini seçiyoruz. Otomatik Arttırma özelliği sayesinde tabloya veri eklendiğinde **id** içindeki değer her eklemede artacaktır. Bu da her satır için ayırıcı bir özellik olacaktır. **ad** alanının tipini **TEXT** yapıyoruz. **OK** butonuna basarak tabloyu oluşturuyoruz.\n\n\\\nBöylelikle içerisinde adları depolayabileceğimiz bir veri tabanı olşturmuş olacağız. Oluşturduğumuz tablo her **ad** alanını belirterek veri ekleyişimizde o verinin yanındaki **id** alanına satıra özel numara verecektir.\n\n![](../.gitbook/assets/vt3.png)\n\nTablomuz içindeki kayıtları görmek için **Browse Data** sekmesine tıklayalım. **Table** kısmının yanında tablo oluştururken yazdığımız **kisiler** seçeneğini seçelim. Şuanlık tablomuz boş. Çünkü içine bir kayıtta bulunmadık. **DB Browser** programına bize yardımcı olduğu için teşekkür ederek artık Golang kodlama tarafına geçebiliriz.\\\n\n\n**sqlite3 Kütüphanesinin Kullanımı**\\\n**main.go** dosyamızı oluşturalım. Kütüphanelerimizi import edelim.\n\n```go\nimport (\n \"database/sql\"\n \"fmt\"\n _ \"github.com/mattn/go-sqlite3\"\n)\n```\n\n**database/sql** ile Go üzerinde veri tabanı işlemleri yapabiliyoruz. **fmt**’yi zaten biliyoruz. **github.com/mattn/go-sqlite3** ile de **sqlite3** kullanarak veritabanımızı yönetebiliriz. Buranın başına **\\_ (alt tire)** eklememizin sebebi **vscode** programı bu kütüphanenin kod içersinde kullanılmadığını düşünerek silmesini önlemek içindir. Basit şekilde veri tabanı bağlantısı nasıl yapılır görelim.\n\n```go\npackage main\nimport (\n \"database/sql\"\n \"fmt\"\n _ \"github.com/mattn/go-sqlite3\"\n)\nfunc main() {\n vt, _ := sql.Open(\"sqlite3\", \"./veritabanı.db\") //veri tabanı dosyamız\n //Veri tabanı işlemleri için kodları yazacağımız bölüm\n vt.Close() //İşimiz bittikten sonra veri tabanımızı kapatıyoruz\n}\n```\n\n**sqlite3 Veri Ekleme İşlemi**\n\n```go\nfunc main() {\n vt, _ := sql.Open(\"sqlite3\", \"./veritabanı.db\")\n işlem, _ := vt.Prepare(\"INSERT INTO kisiler(ad) values(?)\")\n //Hangi bölüme eklenecekse yukarıda orayı belirtiyoruz\n veri, _ := işlem.Exec(\"Mustafa Kemal ATATÜRK\") //Eklenecek değer\n id, _ := veri.LastInsertId() //Son girişin id numarısını aldık\n fmt.Println(\"Son kişinin id'si\", id)\n vt.Close() //İşimiz bittikten sonra veri tabanımızı kapatıyoruz\n}\n```\n\n**sqlite3 Veri Güncelleme İşlemi**\n\n```go\nfunc main() {\n vt, _ := sql.Open(\"sqlite3\", \"./veritabanı.db\")\n id:=1\n //değiştirilecek kısmın id numarası\n işlem, _ := vt.Prepare(\"update kisiler set ad=? where id=?\")\n //Güncellenecek kısmı belirtiyoruz\n veri, _ := işlem.Exec(\"Gazi M. K. ATATÜRK\", id)\n //Değişiklik ve Değiştirilen verinin id'si\n değişiklik, _ := veri.RowsAffected()\n fmt.Println(\"Değişen kişinin id'si: \", değişiklik)\n vt.Close() //İşimiz bittikten sonra veri tabanımızı kapatıyoruz\n}\n```\n\n**sqlite3 Veri Silme İşlemi**\n\n```go\nfunc main() {\n vt, _ := sql.Open(\"sqlite3\", \"./veritabanı.db\")\n işlem, _ := vt.Prepare(\"delete from kisiler where id=?\")\n //id numarasına göre sileceğiz\n veri, _ := işlem.Exec(id) //Silinecek kişinin id'si\n değişiklik, _ := veri.RowsAffected() //Silinen kişinin id'sini aldık\n fmt.Println(\"Silinen kişinin id'si: \", değişiklik)\n vt.Close()\n}\n```\n\n**sqlite3 Veri Sorgulama İşlemi**\n\n```go\nfunc main() {\n vt, _ := sql.Open(\"sqlite3\", \"./veritabanı.db\")\n tablo, _ := vt.Query(\"SELECT * FROM kisiler\")\n //Bu kısma sorguyu kullanıcağımız kodları yazacağız.\n tablo.Close() //İşimiz bittiği için tablo sorgulamayı kapattık\n vt.Close() //İşimiz bittikten sonra veri tabanımızı kapatıyoruz\n}\n```\n\nYukarıda **kisiler** tablosundaki tüm verileri sorgulamış olduk. Bir sonraki bölümde tablomuzdaki verileri nasıl kullanıcıya gösterebileceğimizi öğreneceğiz.\\\n**sqlite3 Verileri Sıralama/Gösterme İşlemi**\n\n```go\nfunc main() {\n vt, _ := sql.Open(\"sqlite3\", \"./veritabanı.db\")\n tablo, _ := vt.Query(\"SELECT * FROM kisiler\")\n var id int\n var ad string\n for tablo.Next() {\n  aktarma := tablo.Scan(&id, &ad)\n  //Tablo bölümlerini değişkenlere aktardık\n  if aktarma == nil { //Boş mu kontol ediyoruz\n   fmt.Println(\"Kişiler listesi boş\")\n  }else{\n   //Boş değilse verileri ekrana bastırıyoruz\n   fmt.Println(id, ad)\n  }\n }\n tablo.Close() //İşimiz bittiği için tablo sorgulamayı kapattık\n vt.Close() //İşimiz bittikten sonra veri tabanımızı kapatıyoruz\n}\n```\n" }, { "path": "web-sunucu-server-ag-istemleri/gin-web-kuetuephanesi/README.md", "content": "# Gin Web Kütüphanesi\n\nGin Go'da yazılmış bir web kütüphanesidir. Performans ve üretkenlik odaklıdır. Sizlere basitçe web sunucu ve api oluşturmanız için kolaylık sağlar.\n\nKurulum için:\n\n> go get -u github.com/gin-gonic/gin\n\nDaha sonra yine aynı yöntemle projemize dahil edebiliriz.\n\n```go\nimport \"github.com/gin-gonic/gin\"\n```\n\nBasit bir web sunucu oluşturma örneği:\n\n```go\npackage main\n\nimport (\n\t// kütüphanemizi içeri aktaralım\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc main() {\n\t//gin'in varsayılan ayarlarında bir yönlendirici oluşturalım.\n\trouter := gin.Default()\n\n\t//anasayfayı inde fonksiyonumuz yakalayacak\n\trouter.GET(\"/\", index)\n\n\t//daha sonra sunucuyu başlatıyoruz\n\trouter.Run()\n}\n\n//anasayfayı yakalayacak olan fonksiyonumuz\nfunc index(c *gin.Context) {\n\t//c ile gin nesnemize bağlam oluşturduk.\n\t//c'yi kullanarak artık gin özelliklerine erişebiliriz.\n\n\t//sayfaya düz yazı gönderdik\n\tc.String(200, \"Merhaba Dünya\")\n\t//Buradaki 200 sunucudan bir cevap geldiğini anlamına gelir\n}\n```\n\nProgramımızı çalıştırdığımızda aşağıdaki gibi konsol çıktısı alacağız.\n\n> \\[GIN-debug] \\[WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n>\n> \\[GIN-debug] \\[WARNING] Running in \"debug\" mode. Switch to \"release\" mode in production.\n>\n> * using env: export GIN\\_MODE=release\n> * using code: gin.SetMode(gin.ReleaseMode)\n>\n> \\[GIN-debug] GET / --> main.index (3 handlers)\\\n> \\[GIN-debug] Listening and serving HTTP on :8080\n\nBu çıktıyı incelediğimizde, Gin'in debug (hata ayıklama) modunda çalıştığını söylüyor ve hemen aşağısında sunucumuz ürün haline gelince Gin'i Release Moduna nasıl alacağımızı gösteriyor. Son olarak ise web sunucumuzun `8080` portunda çalıştığınız gösteriyor.\n\nYukarıdaki örnekte web sunucumuz varsayılan olarak `8080` protunda çalışacaktır. Bunun sebebi `router.Run()`'a parametre olarak port numarası vermememizdir.\n\nÖrneğe göre [http://localhost:8080](http://localhost:8080) adresine gittiğimizde komut satırında yeni detaylar belirecek. Tıpkı aşağıdaki gibi:\n\n![Komut satırı bilgisi](../../.gitbook/assets/go-gin.png)\n\nBu bilgileri inceleyelim. İlk kayıt anasayfaya bağlanılmaya çalışıldığında alınmış. Bu kayıtta bağlantının zamanını, durum kodunu, bağlantı süresi, bağlantı yöntemini ve hangi adrese bağlantı denendiğini yazıyor. Hemen altındaki ise sitenin ikonuna istek yapmış fakat site ikonumuz bulunmadığı için **404 durum kodu**nu almış. Bu kısımdan da bağlantı isteklerini görebildiğimizi öğrenmiş olduk.\n\n## 🔘 Çıktı Tipleri\n\n### ➡️ JSON Çıktı Verme\n\n```go\nfunc index(c *gin.Context) {\n\t//JSON Fonksiyonunu kullanıyoruz.\n\tc.JSON(200, gin.H{\n\t\t\"ad\": \"kaan\",\n\t\t\"soyad\": \"kuşcu\",\n\t})\n}\n```\n\nSonucumuz aşağıdaki gibi olacaktır.\n\n![JSON çıktısı](../../.gitbook/assets/gin-json.png)\n\n### ➡️ XML Çıktı Verme\n\n```go\n//xml için örnek bir yapı oluşturalım\ntype xmlYapı struct {\n\tAd string `xml:\"ad\"`\n\tSoyad string `xml:\"soyad\"`\n}\n\n//anasayfayı yakalayacak olan fonksiyonumuz\nfunc index(c *gin.Context) {\n\t//xml için örnek bir nesne oluşturduk\n\txmlOrnek := xmlYapı{\"kaan\", \"kuşcu\"}\n\n\t//xml başlığını gönderelim\n\tc.Writer.WriteString(xml.Header) //\n\n\t//xml nesnesini XML fonksiyonu ile yolladık\n\tc.XML(200, xmlOrnek)\n}\n```\n\nBu kodlar sonucunda sayfamızı açtığımızda \"kaankuşcu\" sonucu göreceğiz. XML tipinde görmek için sayfanıza sağ tıklayıp \"_Sayfa Kaynağını Gör_\"e tıklayarak kontrol edebilirsiniz.\n\n![XML sonucu](<../../.gitbook/assets/image (1).png>)\n\n\n\n### ➡️ Template Kullanımı\n\nTemplate hakkında bilginiz yoksa önce aşağıdaki dökümanı okumanız önerilir.\n\n{% content-ref url=\"../html-sablonlar-templates.md\" %}\n[html-sablonlar-templates.md](../html-sablonlar-templates.md)\n{% endcontent-ref %}\n\nGin'de template (şablon) işlemleri bayağı kolaylaştırılmış. Ufak bir örnek uygulama yazalım. Öncelikle projemizin ana dizinine `templates` isimli bir klasör oluşturalım ve içerisine `index.html` dosyası oluşturalım. `index.html` dosyamızın içeriği ise aşağıdaki gibi olsun.\n\n```markup\n\n\t

\n\t\t{{ .başlık }}\n\t

\n\n```\n\nBurada `{{ .başlık }}` yerine Go'dan değer göndereceğiz.\n\n`main.go` dosyamız ise aşağıdaki gibi olsun.\n\n```go\npackage main\n\nimport (\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc main() {\n\trouter := gin.Default()\n\n\t//Burada templates klasörünün içindeki tüm şablonları\n\t//yüklemesini isteyelim.\n\trouter.LoadHTMLGlob(\"templates/*\")\n\n\trouter.GET(\"/\", index)\n\n\trouter.Run()\n}\n\nfunc index(c *gin.Context) {\n\n\t//HTML şablonunu almak için\n\t//HTML fonksiyonunu kullanıyoruz.\n\tc.HTML(200, \"index.html\", gin.H{\n\t\t//Şablondaki başlık yerine Anasayfa yazısını yollayalım.\n\t\t\"başlık\": \"Anasayfa\",\n\t})\n}\n```\n\nWeb sunucumuza bağlandığımızda ise **Anasayfa** yazdığını görebiliriz.\n\n## 🔘 Statik Dosyaları Yayınlama\n\nWeb sunucumuzda kullanacağımız Css, JS vb. statik dosyalarımız olabilir. Bunun için `Static` fonksiyonunu kullanabiliriz.\n\nStatik dosyalarımızı projemizin ana dizindeki `statik` klasöründe barındırdığımızı varsayalım.\n\n```go\nfunc main() {\n\trouter := gin.Default()\n\n\t//(yönlendirme, klasör-ismi)\n\trouter.Static(\"/static\", \"./statik\")\n\t\n\trouter.GET(\"/\", index)\n\n\trouter.Run(\":9000\")\n}\n```\n\n`statik` klasörümüzün içerisinde `index.js` adında bir dosya olduğunu varsayarsak `http://localhost:9000/static/index.js` adresinden ulaşabiliriz.\n\n## 🔘 Bağlantı Metodları\n\nÖrnek bağlantı oluştururken GET metoduna değindik. Metodları test ediyorken **Postman**'i kullanabilirsiniz. Ben bu konuda **curl** komut satırı aracını kullanacağım. Detaylarına bakacak olursak:\n\n### ➡️ GET Metodu\n\n`GET` metodu web sunucumuza normal bağlantı yapılırken kullanılır. Hazır bir kaynağı yüklemek için kullanılır.\n\n```go\nrouter.GET(\"/\", index)\n```\n\n`index` fonksiyonu ile `GET` metodlu anasayfayı yakalayabilirsiniz.\n\n### ➡️ POST Metodu\n\nPOST metodu genellikle form gönderimlerinde kullanılır. Yeni bir kaynak oluşturmak için kullanılır. (Yeni kayıt oluşturma, yeni gönderi oluşturma vb...)\n\nÖrnek kullanımını görelim.\n\n```go\npackage main\n\nimport (\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc main() {\n\trouter := gin.Default()\n\n\t//Burada templates klasörünün içindeki tüm şablonları\n\t//yüklemesini isteyelim.\n\trouter.LoadHTMLGlob(\"templates/*\")\n\n\trouter.GET(\"/\", getIndex)\n\trouter.POST(\"/\", postIndex)\n\n\trouter.Run(\":9000\")\n}\n\nfunc getIndex(c *gin.Context) {\n\tc.String(200, \"GET metodu ile bağlanıldı.\")\n}\n\nfunc postIndex(c *gin.Context) {\n\tc.String(200, \"POST metodu ile bağlanıldı.\")\n}\n```\n\nYukarıdaki örnekte anasayfa `GET` ile bağlanıldığında `getIndex`, `POST` ile bağlanıldığında `postIndex` fonksiyonu çalışacak. Tarayıcımızdan girdiğimizde \"_GET metodu ile bağlanıldı._\" yazısını görürüz. `POST` metodu ile bağlanmak için komut satırına şu komutları yazalım.\n\n> curl -X POST http://localhost:9000\n\nÇıktısı \"_POST metodu ile bağlanıldı._\" olacaktır.\n\nPOST metodu üzerinden değer almayı görelim.\n\n```go\n//json verisi için yapımız\ntype kişi struct {\n\tAd string `json:\"ad\"`\n\tSoyad string `json:\"soyad\"`\n}\n\nfunc postIndex(c *gin.Context) {\n\t//posttan gelen json'ın kaydedileceği değişken\n\tvar postkişi kişi\n\n\t//postan gelen json'ı postkişi'ye atayalım\n\tc.BindJSON(&postkişi)\n\n\n\tc.String(200, \"JSON Veri:\")\n\t//json'ı tekrar post ile gösterelim\n\tc.JSON(200, postkişi)\n}\n```\n\nKomut satırına aşağıdaki komutu yazarak çıktısını görebilirsiniz.\n\n> curl -X POST -H \"Content-Type: application/json\" -d '{\"ad\":\"kaan\",\"soyad\":\"kuşcu\"}' [http://localhost:9000](http://localhost:9000)\n\n### ➡️ Diğer Metodlar\n\nDiğer metodlardan kısaca bahsedelim:\n\n* **PATCH metodu:** Bir kaynak üzerindeki belirli bir alanı değiştirmek için kullanılır.\n* **DELETE metodu:** Sunucudaki bir kaynağı silmeye yarar.\n* **PUT metodu:** Bir kaynağın yerine başka bir kaynağı koymaya yarar. (Komple değiştirme)\n* **HEAD metodu:** Sunucuya tıpkı GET metodu gibi fakat sadece başlığı olan bir istek gönderir.\n* **OPTIONS metodu:** Sunucunun desteklediği metodları kontrol etmek için kullanılır.\n\n## 🔘 Adreslendirme\n\n### ➡️ Parametre ile Adreslendirme\n\nÖrneğin:\n\n![Gin parametre örneği](../../.gitbook/assets/gin-param.png)\n\n```go\npackage main\n\nimport (\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc main() {\n\trouter := gin.Default()\n\n\trouter.GET(\"/blog/:yazı\", blog)\n\t//Buradaki :yazı bizim parametremiz\n\t//Bu parametre ile hangi blog yazısını\n\t//göstereceğimizi belirleyeceğiz.\n\n\trouter.Run(\":9000\")\n}\nfunc blog(c *gin.Context) {\n\t//yazı parametresininde geleni sayfaİsmi değişkenine atayalım.\n\tsayfaİsmi := c.Param(\"yazı\")\n\tc.String(200, \"Şuanda \"+sayfaİsmi+\" blogunu okuyorsunuz.\")\n}\n```\n\nYukarıdaki örneğe göre [http://localhost:9000/blog/gin%20ile%20sunucu%20geli%C5%9Ftirme](http://localhost:9000/blog/gin%20ile%20sunucu%20geli%C5%9Ftirme) adresine gittiğimizde \"_Şuanda gin ile sunucu geliştirme blogunu okuyorsunuz._\" yazısı ile karşılacağız.\n\nTabi ki birden fazla parametre ekleyebilirsiniz.\n\n```go\npackage main\n\nimport (\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc main() {\n\trouter := gin.Default()\n\n\trouter.GET(\"/blog/:yazar/:yazı\", blog)\n\n\trouter.Run(\":9000\")\n}\nfunc blog(c *gin.Context) {\n\tyazar := c.Param(\"yazar\")\n\tyazı := c.Param(\"yazı\")\n\tc.String(200, \"Yazar: \"+yazar+\" Yazı: \"+yazı)\n}\n```\n\n### ➡️ Querystring (Sorgu dizesi) ile Adreslendirme\n\nÖrneğin:\n\n![Gin sorgu sizesi örneği](../../.gitbook/assets/gin-querystring.png)\n\n```go\npackage main\n\nimport (\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc main() {\n\trouter := gin.Default()\n\n\trouter.GET(\"/arama\", arama)\n\n\trouter.Run(\":9000\")\n}\nfunc arama(c *gin.Context) {\n\ttür := c.Query(\"tur\")\n\tsıralama := c.Query(\"siralama\")\n\tc.String(200, tür+\" türünden filmler \"+sıralama+\" olarak sıralanıyor.\")\n}\n```\n\nYukarıdaki örneğe göre [http://localhost:9000/arama?tur=bilim-kurgu\\&siralama=imdb](http://localhost:9000/arama?tur=bilim-kurgu\\&siralama=imdb) adresine girdiğimizde \"_bilim-kurgu türünden filmler imdb olarak sıralanıyor._\" yazılı bir sonuç elde edeceğiz.\n\n### Göz atmanızı önerdiğim yazı:\n\n{% embed url=\"https://kaanksc.com/go-web-sunucuda-kullanici-girisi-sistemi\" %}\n\n" }, { "path": "web-sunucu-server-ag-istemleri/gin-web-kuetuephanesi/gin-dosya-yuekleme.md", "content": "# Gin Dosya Yükleme\n\nBu yazıda Gin kütüphanesinden `POST` isteği ile nasıl dosya yükleyeceğimizi göreceğiz.\n\nAşağıda projemizin dizin/dosya yapısı bulunuyor.\n\n```\n.\n├── main.go\n└── public\n └── index.html\n```\n\nİlk olarak `index.html` dosyamızı görelim.\n\n```markup\n\n\n\n\n \n Dosya Yükle\n\n\n\n

Yüklemek için 1 adet dosya seçin

\n\n
\n İsim:
\n E-posta:
\n Dosya:

\n \n
\n\n```\n\nDetaylıca değinmiyorum. `input` elementlerinin `name` özelliğinde ne isim verdiğimizi dikkat etmemiz yeterli. `form` elementinin action özelliğine `/yukle` adresini verdik.\n\n`main.go` dosyamız ise aşağıdaki gibi olacaktır. Detaylarına yorum satırlarında değindim.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"path/filepath\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc main() {\n\n\trouter := gin.Default()\n\t//Yükleme yapacağımız dosyanın maksimum boyutunu\n\t//ayarlayalım.\n\trouter.MaxMultipartMemory = 8 << 20 // 8 MiB\n\n\t//index.html dosyamızın bulunduğu klasörü static olarak\n\t//ekliyoruz ki index.html dosyamızı kullanabilelim.\n\trouter.Static(\"/\", \"./website\")\n\n\t//yukleme işlemini yapacak olduğumuz yönlendirmeyi\n\t//buradan ayarlıyoruz.\n\trouter.POST(\"/yukle\", func(c *gin.Context) {\n\n\t\t//form içerisindeki dosya hariç verilerimizi\n\t\t//atayalım\n\t\tisim := c.PostForm(\"isim\")\n\t\teposta := c.PostForm(\"email\")\n\n\t\t// Dosyamızı ise özel fonksiyon ile atıyoruz\n\t\tdosya, hata := c.FormFile(\"dosya\")\n\n\t\t//Hata kontrolü yapmayı unutmayalım.\n\t\tif hata != nil {\n\t\t\tc.String(400, fmt.Sprintf(\"Form Hatası: %s\", hata.Error()))\n\t\t\treturn\n\t\t}\n\n\t\t//yüklenecek olan dosyanın ismini alalım.\n\t\tdosyaismi := filepath.Base(dosya.Filename)\n\n\t\t//yüklenen dosyanın kaydedileceği konum\n\t\t// dizin + dosyaismi\n\t\tkayıtYeri := \"./website/\" + dosyaismi\n\n\t\t//dosyayı kaydedelim ve hata kontrolü yapalım.\n\t\tif hata := c.SaveUploadedFile(dosya, kayıtYeri); hata != nil {\n\t\t\tc.String(400, fmt.Sprintf(\"Dosya Yükleme Hatası: %s\", hata.Error()))\n\t\t\treturn\n\t\t}\n\n\t\t//Şuana kadar herhangi bir sıkıntı ile\n\t\t//karşılaşmadıysak, olumlu mesajımızı gösterelim.\n\t\tc.String(200, fmt.Sprintf(\"%s isimli dosya başarıyla yüklendi \\nİsim: %s\\nE-posta: %s\", dosya.Filename, isim, eposta))\n\t})\n\trouter.Run(\":8080\")\n}\n```\n" }, { "path": "web-sunucu-server-ag-istemleri/grpc.md", "content": "# gRPC\n\n## gRPC Nedir?\n\ngRPC, Google tarafından geliştirilen, açık kaynaklı uzaktan prosedür çağırma (rpc) kütüphanesi (sistemi)'dir. Aktarım için `HTTP/2` kullanır. Arayüz tanımlama dili olarak `protokol tamponları (buffers)` kullanır. Kimlik doğrulama, Çift yönlü akış, engelleme ve engelleme olmayan bağlantılar, iptal ve zaman aşımı işlemleri için kullanılır.\n\nJSON ve HTTP API'larının aksine, daha katı bir spesifikasyona sahiptirler. Tek bir spesifikasyona sahip olduğu için, gRPC tartışmalarını ortadan kaldırır ve geliştiriciye zaman kazandırır. Çünkü gRPC, platformlar ve uygulamalar arasında tutarlıdır.\n\nÖzet olarak, uzaktan prosedür çağırarak client (müşteri) ve server (sunucu) programları arasındaki iletişimi sağlayan bir kütüphanedir.\n\n## Protokol Tamponları (Buffers) Nedir?\n\nİki uygulama arasındaki iletişimin nasıl olacağını belirleyen sözleşmedir.\n\n## Örnek Uygulama Yapalım\n\nBu örneğimizde sunucuya mesaj gönderip, karşılığında mesaj alan bir uygulama yazacağız. Bir nevi chat uygulaması olacak.\n\nÖncelikle, iletişim protokülünü Go koduna dönüştürebilmemiz (generating) için `protoc`'yi bilgisayarımıza kuralım.\n\nİndirmek için [buradaki](https://github.com/protocolbuffers/protobuf/releases/tag/v3.13.0) adrese gidin. Buradaki versiyon v3.13.0 versiyonu. Daha güncel versiyonlar için [buradaki](https://github.com/protocolbuffers/protobuf/releases/) sayfayı kontrol etmeyi unutmayın.\n\n![](../.gitbook/assets/protoc-download.png)\n\nGNU/Linux İS kullanan arkadaşlarımız uygulama depolarından protobuf adıyla yükleyebilirler. Böylece PATH olarak eklemelerine gerek kalmaz.\n\n## Sisteme Yol Olarak Ekleme\n\nEğer GitHub sayfasından indirdiyseniz, sisteminize dosya yolunu tanıtmanız gerekir. Bunun için örnek olarak;\n\n### Windows üzerinde\n\nÖrnek olarak `protoc.exe` dosyamız `C:\\\\protoc\\bin` klasörü içerisinde olsun.\n\nBaşlar menüsünde _\"Ortam değişkenleri\"_ yazarak aratalım. Açılan pencerede _Gelişmiş_ sekmesinde alt tarafta _Ortam Değişkenleri_ butonuna basalım.\n\n_PATH_ seçeneğini _Düzenle_ diyerek `protoc.exe`'nin konumunu ekleyelim.\n\n### GNU/Linux, MacOS vs. Bash Kullanan Sistemler Üzerinde\n\n`protoc` çalıştırılabilir dosyamızı örnek olarak `Home (Ev)` dizinine atmış olalım.\n\n**Örnek:** `~/protoc/bin` olsun.\n\nEv dizinimizdeki `.bashrc` dosyamızın en altına şunları ekleyelim.\n\n```\nexport PATH=\"~/protoc/bin:$PATH\"\n```\n\n`.bashrc` dosyasını kaydettikten sonra komut satırına `source ~/.bashrc` yazarak dosyada yaptığımız değişimi onaylayalım.\n\n#### Protoc'yi kontrol edelim\n\nKomut satırına aşağıdakileri yazarak `protoc`'nin versiyonuna bakalım.\n\n```\nprotoc --version\n```\n\n`Protoc`'ye Golang desteğini eklemek için aşağıdaki paketleri kuralım.\n\n```\ngo get google.golang.org/protobuf/cmd/protoc-gen-go\ngo get google.golang.org/protobuf/cmd/protoc-gen-go-grpc\n```\n\nAynı şekilde Windows üzerinde `C:\\\\Users\\isim\\go\\bin` klasörünü ekli değilse ortam değişkenlerine ekleyelim. Unix-like sistemler için `~/go/bin`'i path'e ekleyelim.\n\nYukarıda belirttiğimiz örnek `chat` uygulamasını yazmak için aşağıdaki gibi bir proje yapımız olacak.\n\n```\n.\n├── chat\n│ └── chat.go\n├── chat.proto\n├── client.go\n└── server.go\n```\n\nClient ve Server arasındaki iletişim protokolünü belirleyelim.\n\n`chat.proto` dosyamız şöyle olsun.\n\n```groovy\n//Söz dizimi için proto3'ü kullanacağız\nsyntax = \"proto3\";\n\n//Go paketi için ayarlarımız\npackage chat;\noption go_package=\".;chat\";\n\n//iletişimde kullanılacak mesajın yapısı\nmessage Message {\n string body = 1;\n //buradaki 1 sıra numarasıdır. Değer ataması değildir.\n}\n\n//rpc servisimiz\nservice ChatService {\n rpc SayHello(Message) returns (Message) {}\n}\n```\n\nYukarıdaki `chat.proto` dosyasını Go koduna dönüştürelim. Bunun için proje dizinindeyken aşağıdaki komutu yazalım.\n\n> protoc --go\\_out=plugins=grpc:chat chat.proto\n\nBu işlem sonucunda chat klasörümüzüm içerisinde `chat.pb.go` dosyamız oluşacak. Bu dosyanın en başında yorum olarak düzenleme yapmamızın uygun olamayacağı yazıyor. O yüzden bu dosyayla çok uğraşmamakta fayda var.\n\n## Server (Sunucu) Oluşturalım\n\n`chat` klasörümüzdeki `chat.go` dosyasını oluşturalım.\n\n```go\npackage chat\n\nimport (\n\t\"log\"\n\n\t\"golang.org/x/net/context\"\n)\n\ntype Server struct {\n\t//Burası şuanlık boş olacak\n}\n\n//server nesnemize iliştirilecek fonksiyonumuz\nfunc (s *Server) SayHello(ctx context.Context, message *Message) (*Message, error) {\n\n\t//Client'ten gelen mesajı ekrana bastıralım\n\tlog.Printf(\"Clientten mesaj alındı: %s\", message.Body)\n\n\t//mesaj gelince değer döndürelim (mesaj ve hata)\n\treturn &Message{Body: \"Server'dan merhaba!\"}, nil //hata nil olsun\n}\n```\n\nGo modules'tan faydalanarak chat paketini diğer paketlerde kullanabiliriz. Bunun için proje dizinindeyken komut satırına:\n\n> go mod init github.com/ksckaan1/grpcOrnek\n\nyazalım. Buradaki yaptığımız şey, GitHub'a paket yüklemeden sanal olarak yazdığımız `chat` paketini kullanabileceğiz. Bu komuttan sonra proje dizinimizde `go.mod` dosyası oluşacak. Böylece chat klasörünü paket olarak diğer yerlerde de kullanabileceğiz.\n\n`server.go` dosyamızı oluşturalım.\n\n```go\npackage main\n\nimport (\n\t\"log\"\n\t\"net\"\n\n\t\"github.com/ksckaan1/grpcExample/chat\"\n\t\"google.golang.org/grpc\"\n)\n\nfunc main() {\n\n\t//tcp dinleyelim\n\tlis, err := net.Listen(\"tcp\", \":9080\")\n\n\t//hata kontrolü yapalım\n\tif err != nil {\n\t\tlog.Fatalf(\"9080 portu dinlenirken hata oluştu: %v \\n\", err)\n\t}\n\n\t//chat server nesnesi oluşturalım\n\ts := chat.Server{}\n\n\t//grpc server'ı oluşturalım.\n\tgrpcServer := grpc.NewServer()\n\n\t//tcp sunucu ile grpc'yi bağlayalım.\n\tchat.RegisterChatServiceServer(grpcServer, &s)\n\n\t//hata kontrolü\n\tif err := grpcServer.Serve(lis); err != nil {\n\t\tlog.Fatalf(\"grpcServer oluşturulurken hata : %v\", err)\n\t}\n}\n```\n\n`go run server.go` komutunu yazarak test edelim. Eğer çıktı vermiyorsa ve program kapanmıyorsa server dinleniyor demektir. Yani şuana kadar başarılıyız.\n\n## Client (Müşteri) Oluşturalım\n\nŞimdi de Server'a mesaj yollayabilmek için Client'i oluşturalım. `client.go` dosyamız aşağıdaki gibi olsun.\n\n```go\npackage main\n\nimport (\n\t\"log\"\n\n\t//chat klasörünü kullanacağımız için\n\t//go mod init üzerinde belirlediğimiz deponun\n\t//sonuna /chat ekliyoruz.\n\t\"github.com/ksckaan1/grpcExample/chat\"\n\t\"golang.org/x/net/context\"\n\n\t//grpc kütüphanemiz\n\t\"google.golang.org/grpc\"\n)\n\nfunc main() {\n\n\t//grpc client bağlantı nesnesi\n\tvar conn *grpc.ClientConn\n\n\t//grpc ye 9080 portunu dinlemesini söyleyelim\n\tconn, err := grpc.Dial(\":9080\", grpc.WithInsecure())\n\tif err != nil {\n\t\tlog.Fatalf(\"9080 portu dinlenirken hata oluştu: %v\", err)\n\t}\n\n\t//bağlantığı kapatmayı unutmayalım\n\tdefer conn.Close()\n\n\t//Client nesnesi oluşturalım\n\tc := chat.NewChatServiceClient(conn)\n\n\t//server'a gönderilecek mesajı belirleyelim\n\tmessage := chat.Message{\n\t\tBody: \"Client'ten merhabalar!\",\n\t}\n\t\n\t//Server'dan dönen cevabı alalım\n\tresponse, err := c.SayHello(context.Background(), &message)\n\n\t//hata kontrolü yapalım.\n\tif err != nil {\n\t\tlog.Fatalf(\"SayHello fonksiyonu çağırılıken hata oluştu: %v\", err)\n\t}\n\n\t//server'dan gelen mesajı ekrana bastıralım\n\tlog.Printf(\"Server'dan gelen cevap: %s\", response.Body)\n}\n```\n\nYukarıda yazdığımız kodların çalışma mantığını açıklayacak olursak:\n\n1. Server `9080` portunu belirlediğimiz protokol sözleşmesine (_chat.proto_) göre dinliyor.\n2. `Client.go` dosyamız çalıştırılınca server'a mesaj yolluyor.\n3. Client'ten gelen mesajı server ekrana bastırıyor ve bunun karşılığında server client'e cevap veriyor.\n4. Server'dan gelen cevabı da client ekrana bastırıyor.\n5. Son olarak client programımız sonlanıyor (kapanıyor).\n\nGif olarak sonucu göstermek gerekirse:\n\n![gRPC Örneği](../.gitbook/assets/golang-grpc-example.gif)\n" }, { "path": "web-sunucu-server-ag-istemleri/herokuda-go-uygulamasi-yayinlama.md", "content": "# Heroku'da Go Uygulaması Yayınlama\n\n## Öncelikle Bilmeyenler İçin Heroku Nedir?\n\nKısaca Heroku, JavaScript, Go, Ruby, Python, Scala, PHP, Java, Clojure ile geliştirdiğimiz sunucu uygulamalarını ücretsiz barındırabileceğimiz bir platformdur.\n\nAşağıdaki bağlantıdaki blog yazısını okumanızı tavsiye ederim.\n\n{% embed url=\"https://ceaksan.com/tr/heroku-nedir\" %}\n\n## Projemizi Planlayalım\n\nBu örneğimizde bir web sunucu oluşturacağız. Öncelikle `Go modules` kullanacağımız için projemizi kullanıcının go dizinine oluştumalıyız.\n\nKomut satırını açalım ve aşağıdaki komutu yazarak bahsettiğimiz dizine geçelim.\n\nWindows'ta:\n\n> cd C:\\\\\\Users\\\\%username%\\go\\src\n\nGNU/Linux ve MacOS'te:\n\n> cd \\~/go/src\n\nBu konuma proje dizinimizi oluşturalım\n\n> mkdir heroku-app\n\n`heroku-app` klasörü projemizin ana dizini olacak. Aşağıdaki komut ile proje ana dizinimize girelim.\n\n> cd heroku-app\n\nDaha sonra bu dizini `code .` komutu ile VSCode üzerinde açalım.\n\n`main.go` dosyamızı oluşturalım ve aşağıdaki gibi olsun.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"os\"\n)\n\nfunc main() {\n\tport := os.Getenv(\"PORT\")\n\thttp.HandleFunc(\"/\", anaSayfa)\n\thttp.ListenAndServe(\":\"+port, nil)\n}\n\nfunc anaSayfa(w http.ResponseWriter, r *http.Request) {\n\tport := os.Getenv(\"PORT\")\n\tfmt.Fprintf(w, \"Merhaba Dünya!\\nKullanılan Port: \"+port)\n}\n```\n\nYukarıda normal web sunucu oluşturma kodlarından biraz farklı işlemler var. Bunları açıklamak gerekir ise:\n\n`port` değişkenimiz sistemden `string` tipinde `PORT` ortam değişkenini alıyor. Yani `port` değişkeni sunucumuzun hangi portta çalışacağını belirliyor. Uygulamamızı Heroku'ya yükledikten sonra sistemimiz Heroku olduğu için port ortam değişkenini Heroku'dan almış olacağız. Sunucunun çalışacağı portu Heroku belirlediği için portu kendimiz kodlar içinde belirleyemiyoruz.\n\n`http.ListenAndServe()` fonksiyonuna da parametre olarak `\":\"+port` vererek devam ediyoruz.\n\nSunucumuzun ana dizinini yakalacak olan anaSayfa fonksiyonumuza bakalım.\n\nYine burada sistemden portu istedik. Hemen aşağısında \"Merhaba Dünya!\" ve kullanılan portun çıktısını vermesini sağladık. Kodlarımız artık hazır.\n\nBu projemizde dışarıdan bir pakete ihtiyacımız olmadı. Hepsi Go'nun hazır paketlerinden. Eğer dışarıdan paketler olsa ne yapacaktık? Hadi hemen görelim.\n\nKomut satırına go modules için aşağıdaki komutu yazalım.\n\n> go mod init\n\n{% hint style=\"warning\" %}\nEğer projenizi go/src klasörü içinde oluşturmazsanız bu komut hata verecektir.\n{% endhint %}\n\n![go modules örnek ](../.gitbook/assets/go-mod-init.png)\n\nBöylece go.mod dosyamızı oluşturduk. Dışarıdan paket bağımlılıklarını yüklemek için aşağıdaki komutu yazalım.\n\n> go mod vendor\n\nBu komutu yazdığınızda paket bağımlılığınız yoksa aşağıdaki gibi bir çıktı alacaksınız.\n\n![vendor örneği](../.gitbook/assets/no-vendor.png)\n\nEğer paket bağımlılığınız varsa projenizin ana dizininde vendor adında bir klasör oluşacak ve bu klasörün içinde dış paketlerin kaynak kodları bulunanacak.\n\n## Versiyon sistemli hale getirelim\n\nHeroku platformu versiyon kontrol sistemi ile çalıştığı için, öncelikle git projemizi oluşturalım. Projemizin ana dizinindeyken komut satırına:\n\n> git init\n\nDaha sonra oluşturduğumuz projeyi staging'e almak için:\n\n> git add .\n\nyazalım. Commit oluşturmak için ise:\n\n> git commit -m \"Heroku uygulamamı oluşturdum.\"\n\n## Heroku'da Yayınlama\n\nÖncelikle Heroku'nun komut satırı uygulamasını bilgisayarımıza kuralım.\n\nWindows, MacOS ve Ubuntu için [bu adresten](https://devcenter.heroku.com/articles/heroku-cli#download-and-install) kurabilirsiniz.\n\nArch Linux ve türevleri için kolaylık açısından AUR üzerinden `heroku-cli-bin` aratarak kurabilirsiniz.\n\nUygulamayı kurduktan sonra Heroku Hesabımıza bağlayalım.\n\nKomut satırına aşağıdakileri yazalım.\n\n> heroku login\n\nŞöyle bir çıktı verecek:\n\n![Heroku cli Login](../.gitbook/assets/heroku-login.png)\n\nq tuşuna basınca giriş yapmayı iptal eder. O yüzden giriş yapmak için herhangi bir tuşa başabilirsiniz. (Lütfen bilgisayarınızın güç tuşuna basmayın 🙂)\n\nDaha sonra varsayılan tarayıcınız üzerinden giriş yapma sayfası açılacak. Heroku hesabınıza girdikdek sonra tarayıcınızda girişin başarılı olduğunu söylecek.\n\n![Heroku tarayıcı girişi](../.gitbook/assets/heroku-login-warning.png)\n\nKomut satırında da aşağıdaki gibi bir çıktı göreceksiniz. Kendi bilgilerim olduğu için birazını sansürledim.\n\n![Heroku cli başarılı giriş ](../.gitbook/assets/heroku-login-success.png)\n\nBöylece başarıyla giriş yapmış olduk.\n\nHeroku projemizi oluşturalım.\n\n> heroku create\n\nŞöyle bir çıktı alacağız.\n\n![heroku uygulama oluşturma](../.gitbook/assets/heroku-create.png)\n\nYazdığımız kodları Heroku uygulamamıza yükleyelim.\n\n> git push heroku master\n\nBu komut sonrasında aşağıdakine benzer bir sonuç almanız gerekir.\n\n```go\n[kaanksc@KAANHP heroku-app]$ git push heroku master\nEnumerating objects: 4, done.\nCounting objects: 100% (4/4), done.\nDelta compression using up to 4 threads\nCompressing objects: 100% (3/3), done.\nWriting objects: 100% (4/4), 477 bytes | 477.00 KiB/s, done.\nTotal 4 (delta 0), reused 0 (delta 0), pack-reused 0\nremote: Compressing source files... done.\nremote: Building source:\nremote: \nremote: -----> Go app detected\nremote: -----> Fetching jq... done\nremote: -----> Fetching stdlib.sh.v8... done\nremote: -----> \nremote: Detected go modules via go.mod\nremote: -----> \nremote: Detected Module Name: heroku-app\nremote: -----> \nremote: !! The go.mod file for this project does not specify a Go version\nremote: !! \nremote: !! Defaulting to go1.12.17\nremote: !! \nremote: !! For more details see: https://devcenter.heroku.com/articles/go-apps-with-modules#build-configuration\nremote: !! \nremote: -----> New Go Version, clearing old cache\nremote: -----> Installing go1.12.17\nremote: -----> Fetching go1.12.17.linux-amd64.tar.gz... done\nremote: -----> Determining packages to install\nremote: \nremote: Detected the following main packages to install:\nremote: heroku-app\nremote: \nremote: -----> Running: go install -v -tags heroku heroku-app \nremote: heroku-app\nremote: \nremote: Installed the following binaries:\nremote: ./bin/heroku-app\nremote: \nremote: Created a Procfile with the following entries:\nremote: web: bin/heroku-app\nremote: \nremote: If these entries look incomplete or incorrect please create a Procfile with the required entries.\nremote: See https://devcenter.heroku.com/articles/procfile for more details about Procfiles\nremote: \nremote: -----> Discovering process types\nremote: Procfile declares types -> web\nremote: \nremote: -----> Compressing...\nremote: Done: 3.6M\nremote: -----> Launching...\nremote: Released v3\nremote: https://obscure-ocean-33068.herokuapp.com/ deployed to Heroku\nremote: \nremote: Verifying deploy... done.\nTo https://git.heroku.com/obscure-ocean-33068.git\n * [new branch] master -> master\n```\n\nYukarıdaki çıktıya göre aşağıdaki işaretlediğim yerde uygulamamızın adresi olacak.\n\n![Heroku Push sonuç](../.gitbook/assets/heroku-push.png)\n\nBu adres tabiki de sizde farlı olacak. Buradan girip uygulamanızı kontrol edebilirsiniz. Benim sonucum ise şu şekilde:\n\n![Site sonucu](../.gitbook/assets/heroku-site.png)\n" }, { "path": "web-sunucu-server-ag-istemleri/html-sablonlar-templates.md", "content": "# HTML Şablonlar (Templates)\n\nHTML Şablonlar, Golang üzerinde web sayfalarının dinamikliği için kullanılır. Yani şablonlar kullanarak web sayfalarımızın belirlediğimiz bölümlerini Go üzerinden değişikliğe uğratabiliriz.\n\nBu yazımızda HTML şablonların nasıl oluşturulacağına bakacağız. Çalışma mantığı çok basit. Şablon olarak kullanacağımız html dosyasınında sadece tasarımı yapıyoruz ve dinamik olacak kısımlara ise bir nevi işaretler koyuyoruz. Daha sonra Go bu şablon dosyasını işliyor ve işaret koyduğumuz yerlere gelecek değerleri yerleştiriyor. Düz mantık olarak bu işi yapıyor.\n\n## ✨ Örnek Kullanım\n\n```markup\nMerhaba, {{ . }}\n```\n\nYukarıdaki örnekte `{{ }}` süslü parantezler içerisinde . (nokta) yazıyor. Bu da Go şablon işlenirken bu kısma Go tarafından vereceğimiz değerin geleceği anlamına geliyor.\n\nŞimdi yukarıdaki örneğimizi `sablon.html` adı ile kaydedelim.\n\nGelelim Go kodlarımıza;\n\n`main.go` dosyamız aşağıdaki gibi olsun.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"html/template\"\n\t\"net/http\"\n)\n\n// yakalayıcı fonksiyonumuz\nfunc anasayfa(w http.ResponseWriter, r *http.Request) {\n\t//isim değişkenimiz\n\tisim := \"Kaan\"\n\n\t//burada şablon oluşturuyoruz\n\tşablon, _ := template.ParseFiles(\"sablon.html\")\n\n\t//Burada da şablonu çalıştırmasını ve isim\n\t//değişkenini kullanmasını istiyoruz.\n\tşablon.Execute(w, isim)\n}\nfunc main() {\n\tfmt.Println(\"Sunucu Başladı\")\n\n\t//ana dizini anasayfa fonksiyonu ile yakalayalım\n\thttp.HandleFunc(\"/\", anasayfa)\n\n\t//portu 8000 yapalım ve sunucuyu başlatalım\n\thttp.ListenAndServe(\":8000\", nil)\n}\n```\n{% endcode %}\n\nAçıklamaları üstte yazıyor.\n\nSayfamıza bakmak için [http://localhost:8000](http://localhost:8000) adresine gittiğimizde, şöyle bir sonuç ile karşılaşacağız.\n\n![İlk Çıktımız](../.gitbook/assets/2020-11-23\\_22-30.png)\n\nTabi ki burada bir terslik var. b etiketleri gözüküyor. Bunun sebebi tarayıcımızın sayfayı `html` olarak değil de metin dosyası olarak göstermesi. Çözüm için `sablon.html` dosyamızın başına `` ekleyelim. Yani şöyle olacak:\n\n{% code title=\"sablon.html\" %}\n```go\n\nMerhaba, {{ . }}\n```\n{% endcode %}\n\n{% hint style=\"info\" %}\nEğer sadece şablon dosyasında değişiklik yaptıysanız, sunucuyu yeniden başlatmanıza gerek yoktur. Şablon dosyalarındaki değişiklik sunucu açıkken de güncellenir.\n{% endhint %}\n\nSayfayı yenileyerek değişikliğe bakalım. Çıktımız şöyle olacaktır:\n\n![Doğru çıktımız](../.gitbook/assets/2020-11-23\\_22-38.png)\n\nBu sefer doğru bir çıktı üretmiş olduk.\n\nBu yöntemler ile sayfamızda istediğimiz bölüme istediğimiz tipte değerler gönderebiliriz.\n\n## ✨ HTML Kodu Gönderme\n\nBu örneğimizde `sablon.html` dosyamız aşağıdaki gibi olsun.\n\n{% code title=\"sablon.html\" %}\n```go\n\n{{ . }}\n```\n{% endcode %}\n\n`main.go` dosyamız da aşağıdaki gibi olsun.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"html/template\"\n\t\"net/http\"\n)\n\nfunc anasayfa(w http.ResponseWriter, r *http.Request) {\n\t//html kodumuz\n\thtmlKodu := \"

Merhaba

\"\n\n\tşablon, _ := template.ParseFiles(\"sablon.html\")\n\n\tşablon.Execute(w, htmlKodu)\n}\nfunc main() {\n\tfmt.Println(\"Sunucu Başladı\")\n\n\thttp.HandleFunc(\"/\", anasayfa)\n\n\thttp.ListenAndServe(\":8000\", nil)\n}\n```\n{% endcode %}\n\nYukarıdaki örnekte sayfamıza bu sefer html kodu yolluyoruz. Çıktımıza bakalım.\n\n![HTML kodu çıktımız](../.gitbook/assets/htmlw.png)\n\nBurada yine bir şeyler dönüyor. Çıktı yine istediğimiz gibi değil. \"Niye bana yanlış kodları gösteriyorsun Kaan?\" dediğinizi duyar gibiyim. Çünkü ilk önce yapmamamız gereken şeyleri gösteriyorum ki daha akılda kalıcı olsun.\n\nYukarıdaki olayın sebebi şudur: Go tarafından gönderdiğimiz html kodunun aslında `html` tipinde değil de `string` tipinde olması. Bu yüzden html kodumuz düz bir şekilde görünüyor.\n\nÇözüm olarak da Go tarafındaki değişkenimizin tipini `template.HTML` yapacağız. `main.go` dosyamızda `htmlKodu` değişkenimizin tipini değiştirelim.\n\n```go\nvar htmlKodu template.HTML = \"

Merhaba

\"\n```\n\nveya burada değişkenin tipini değiştirmek yerine `şablon.Execute()` fonksiyonunda değişiklik yapabilirsiniz. (Hangisi kolayınıza geliyorsa)\n\n```go\nşablon.Execute(w, template.HTML(htmlKodu))\n```\n\n## ✨ Şablona Struct Gönderme \n\nBuraya kadar şablon dosyamıza hep bir tane değer gönderdik. Birden fazla değer göndermek için ne yapmalıyız?\n\nBu konuda da struct'lardan faydalanabiliriz. Örnek olarak `main.go` dosyamız aşağıdaki gibi olsun.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"html/template\"\n\t\"net/http\"\n)\n\ntype bilgi struct {\n\tBaşlık string\n\tİçerik template.HTML\n}\n\nfunc anasayfa(w http.ResponseWriter, r *http.Request) {\n\tsayfaBilgi := bilgi{\n\t\tBaşlık: \"Sayfa Başlığı\",\n\t\tİçerik: \"sayfa içeriği\",\n\t}\n\tşablon, _ := template.ParseFiles(\"sablon.html\")\n\tşablon.Execute(w, sayfaBilgi)\n}\nfunc main() {\n\tfmt.Println(\"Sunucu Başladı\")\n\thttp.HandleFunc(\"/\", anasayfa)\n\thttp.ListenAndServe(\":8000\", nil)\n}\n```\n\nYukarıda `bilgi` isminde bir struct oluşturduk. Bu struct'ımız `Başlık` ve `İçerik` adında alt değişkenlere sahip. Struct'ın elemanlarını isimlendirirken baş harflerinin büyük olmasına dikkat edelim. Çünkü Şablonlar struct değişkenlerini dışa aktarma mantığı ile kullanır. Bu yüzden baş harflerini büyük yazmazsak değişkenleri sayfaya ulaştıramayız.\n\nDaha sonra `anasayfa` fonksiyonumuz içerisinde `sayfaBilgi` adında `bilgi` struct'ı oluşturduk ve değişkenlerimizin değerlerini girdik. Son olarak `sayfaBilgi`'yi şablona gönderdik.\n\n`sablon.html` dosyamız içerisinde ise `sayfaBilg`i'den gelen değişkenleri yerleştirelim.\n\n{% code title=\"sablon.html\" %}\n```go\n\n

{{ .Başlık }}


\n{{.İçerik}}\n```\n{% endcode %}\n\nYukarıdaki kodlarda dikkat edeceğimiz nokta, tanımlama yaparken noktadan sonra, bilgi struct'ının alt değişkenlerinin ismi ile çağırıyor olmamız.\n\nÇıktımızı görelim:\n\n![Şablonda struct örneği](../.gitbook/assets/str.png)\n\nBuraya kadar şablon mantığını az çok anladığınıza inanıyorum. Buradan sonrasını konu çok uzun olmasın diye hızlıca anlatmaya çalışacağım. Yani buradan sonra çıktıların resimlerini göstermeyeceğim.\n\n## ✨ Şablon İçinde Değişken Atama\n\nŞablon içerisinde oluşturduğumuz değişkenleri tıpkı PHP'deki gibi `$` işareti ile kullanırız.\n\nÖncelikle `main.go` dosyamız aşağıdaki gibi olsun.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"html/template\"\n\t\"net/http\"\n)\n\nfunc anasayfa(w http.ResponseWriter, r *http.Request) {\n\tşablon, _ := template.ParseFiles(\"sablon.html\")\n\n\t//şablona değer göndermeyeceğimiz için burası nil olsun.\n\tşablon.Execute(w, nil)\n}\nfunc main() {\n\tfmt.Println(\"Sunucu Başladı\")\n\thttp.HandleFunc(\"/\", anasayfa)\n\thttp.ListenAndServe(\":8000\", nil)\n}\n\n```\n{% endcode %}\n\n`sablon.html` dosyamız da aşağıdaki gibi olsun.\n\n{% code title=\"sablon.html\" %}\n```go\n\n\n{{ $isim := \"kaan\"}}\n{{ $isim }}\n```\n{% endcode %}\n\nYukarıda gördüğünüz gibi değişkeni tanımlarken ve kullanırken başına `$` işareti koyduk. Çıktımızda _\"kaan\"_ yazacaktır.\n\n## ✨ Şablonda If-Else Kullanımı\n\n```go\n{{if .Reşit}}\n Bu kişi reşittir.\n{{else}}\n Bu kişi reşit değildir.\n{{end}}\n```\n\nYukarıda dikkat etmemiz gereken şey `if-else`'in sonuna `end` eklememiz gerekiyor. Sadece `if` olsaydı bile `end` eklememiz gerekir.\n\nBu kodları yazdıktan sonra çıkan sonuçta boşluklar (boşluk tuşunun boşluğu gibi) oluşabilir. Bunu engellemek için ise aşağıdaki gibi yapabiliriz.\n\n```go\n{{if .Reşit}}\n Bu kişi reşittir.\n{{- else}}\n Bu kişi reşit değildir.\n{{- end}}\n```\n\nYani boşluk oluşan bölgeniz başına `- tire` ekliyoruz.\n\n## ✨ Şablonda Range Döngüsü Kullanımı\n\nRange döngüsü ile web sayfamızın içerisinde bir listenin sıralanmasını sağlayabiliriz.\n\n```go\n
    \n {{range .Liste}}\n {{.}}\n {{end}}\n
\n```\n\n## ✨ Şablon İçerisinde Yorum Satırı Oluşturma\n\nBiliyorsunuz ki, HTML kodu içerisindeki yorumlar sayfa kaynağını göstere tıklayınca gözüküyor. Eğer yorumların gözükmesini istemezsek Şablon yorumu olarak yazabiliriz.\n\n```go\n{{/* Yorumu buraya yazabilirsiniz */}}\n```\n" }, { "path": "web-sunucu-server-ag-istemleri/net-http-ile-web-server-olusturma.md", "content": "# net/http ile Web Server Oluşturma\n\nGolang’ta web sunucusu oluşturma çok basit bir işlemdir.\\\nİlk örneğimizde **localhost:5555** üzerinde çalışacak olan bir web sunucusu oluşturacağız.\n\n```go\npackage main \nimport (\n \"fmt\"\n \"net/http\"\n)\n \nfunc handler(w http.ResponseWriter, r *http.Request) {\n fmt.Fprintf(w, \"Merhaba %s\", r.URL.Path[1:])\n}\n \nfunc main() {\n http.HandleFunc(\"/\", handler)\n http.ListenAndServe(\":5555\", nil)\n \n fmt.Println(\"Web Sunucu\")\n}\n```\n\nTarayıcınız üzerinden **localhost:5555**‘e girdiğinizde sayfada sadece **Merhaba** yazdığını göreceksiniz. Daha sonra adrese **/ahmet** yazıp girdiğiniz zaman yazının **Merhaba ahmet** olarak değiştiğini göreceksiniz.\\\n\n\n**Peki bu olayın açıklaması nedir?**\\\n**main()** fonksiyonunun içerisinde 2 temel fonksiyon bulunuyor. **HandleFunc()** fonksiyonu belirlediğimiz adrese girildiğinde hangi fonksiyonun çalıştırılacağınız belirliyor. **ListenAndServe()** fonksiyonu ise sunucunun ayağa kalkmasını ve istediğimiz bir porttan ulaşılmasını sağlıyor.\\\nEğer sunucuya dosya verme yoluyla işlem yapmasını istiyorsak aşağıdaki yönteme başvurmalıyız.\\\n**index.html** adında bir dosya oluşturuyoruz. İçine aşağıdakileri yazıyoruz ve kaydediyoruz.\n\n```markup\n\n\n\n Sayfa Başlığı\n\n\n Merhaba Dünya\n\n\n```\n\nŞimde de sunucu işlemlerini gerçekleştireceğimiz **main.go** dosyamızı oluşturalım.\n\n```go\npackage main \nimport (\n \"fmt\"\n \"io/ioutil\"\n \"net/http\"\n)\n \nfunc loadFile(fileName string) (string, error) {\n bytes, err := ioutil.ReadFile(fileName)\n if err != nil {\n return \"\", err\n }\n return string(bytes), nil\n}\n \nfunc handler(w http.ResponseWriter, r *http.Request) {\n var body, _ = loadFile(\"index.html\")\n fmt.Fprintf(w, body)\n}\n \nfunc main() {\n http.HandleFunc(\"/\", handler)\n http.ListenAndServe(\":5555\", nil)\n}\n```\n\nTarayıcıdan **localhost:5555** adresine girdiğimiz zaman oluşturmuş olduğumuz **index.html** dosyasının görüntülendiğini göreceksiniz.\\\nAçıklayacak olursak eğer;\\\n**loadFile()** fonksiyonumuz **index.html** programa aktarıldığında **byte** türünde olduğu için onu okuyabileceğimiz **string** türüne çevirdi. Bu özellik programımıza **“io/ioutil”** paketi sayesinde eklendi. Geri kalan kısımdan zaten yukarıda bahsetmiştik.\n" }, { "path": "web-sunucu-server-ag-istemleri/rabbitmq/README.md", "content": "# RabbitMQ\n\n{% hint style=\"info\" %}\nRabbitMQ hakkında bilginiz varsa sonraki sayfaya geçebilirsiniz.\n{% endhint %}\n\n## RabbitMQ Nedir?\n\nÖncelikle RabbitMQ hakkında bilgi edinmek veya bilgilerini tazelemek isteyenler için ufak bir bilgi edinelim.\n\nRabbitMQ, mesaj kuyruğu sistemidir. AMQP üzerinde kurulu bir sistemdir.\n\n### Peki AMQP Nedir?\n\nAMQP'nin açılımı Advenced Message Queue Protocol'dür (Gelişmiş Mesaj Kuyruğu Sistemi).\n\nBasitçe kabul edilen mesajları sıraya göre işleyebileceğimiz bir protokoldür.\n\n\n\n### Peki biz bu sistemi hangi ihtiyaçlarımızı gidermek için kullanırız?\n\nBizim için önemli olan kısım burası. En çok kullanılan alanlar,\n\n* Uzun süren işlemler ve arkaplan işlemleri,\n* Mikroservisler arasındaki iletişim (aracılık),\n* Basitçe dosya işleme (ve alt kategorilerde),\n* Arkaplan sistem ölçekleme ve yedeklemedir.\n\nYukarıdaki maddelerin daha anlaşılır olması için ufak bir senaryo düşünelim.\n\nBir sunucumuz var ve bu sunucumuz bir parametre alarak, bu parametre hakkında belirli mecralardan veri topluyor. Fakat bu veri toplama işi, sistemi yorabilecek bir işlem. Bu parametremizi sistemimizi kullanan kullanıcıdan aldığımızı düşünelim. \n\n#### Peki aynı anda birden fazla kullanıcıdan parametre alıp veri araştırması yaptığımız bir durum ile karşılaşırsak ne olurdu?\n\nBelirli bir işlemden sonra sunucumuzun bulunduğu sistemin kaynakları yetersiz gelirdi ve tabiri caizse sunucumuz çökerdi.\n\nİşte böyle bir örnek durumda Message Queue kullanabiliriz.\n\n## RabbitMQ Çalışma Akışı\n\n![](../../.gitbook/assets/workflow-rabbitmq.png)\n\nYukarıdaki şemada, basitçe bir Message Queue'nin hangi işlemlerden geçtiğini görebiliriz.\n\nKavramlara göz atmak gerekirse;\n\n#### Producer\n\nProducer, mesajımızı RabbitMQ'ya gönderen arkadaşımız. Mesajımız düz bir yazı haricinde bir yapı da (json vs...) olabilir. Bu olayda mesaj diye adlandırılır. Producer basitçe bir yayınlayıcıdır ve RabbitMQ'ya mesajımızı gönderir.\n\n#### Broker\n\nBroker, Producer'dan gelen mesajları sıraya alır ve mesajı almaya müsait olan bir Consumer'a gönderir. Yani mesajlarımızı depolayan bir birimdir.\n\n#### Consumer\n\nComsumer ise broker'a gelen mesajları alır ve istenilen şekilde mesajlar ile işlemler yapabilir. Ve hatta aldığı mesajlara bir yanıt üretebilir (rpc olarak kullanıldığında).\n\n\n\n#### Bahsettiğimiz senaryoya RabbitMQ'yu entegre etseydik, senaryomuz şöyle sonuçlanırdı.\n\nÖrnek olarak kullanıcıdan isim soyisim aldığımızı düşünelim ve bu aldığımızı bilgiyi internette aratarak bilgi toplayacağımızı düşünelim. İşlemimiz uzun sürebileceği için böyle bir işlemi hızlı olmasını istediğimiz bir sunucuda yapmak istemeyebiliriz. Bunun için isim-soyisim'i Broker'ımız olan RabbitMQ'ya mesaj olarak atıyoruz ve bu mesajlarımızı teker teker consumer, yani asıl araştırma yükünü üstlenecek kısım alıp mesaj içeriğine göre araştırma yapacak. Toplanılan bilgiyi bir veritabanına kaydedecek veya istenirse mesajı gönderen producer'a cevap olarak dönebilecek.\n\nEğer cevap olarak dönerse producer'ımız araştırma işlemi bitene kadar bekleyecek fakat sistemimiz birden fazla araştırma yaparak yorulmamış olarak.\n\nİstersek birden fazla consumer oluşturarak aynı anda birden fazla isim-soyisim araştırması da yapabiliriz. Bu biraz da kurduğumuz sisteme bağlı bir işlem.\n\nUfak ufak örnekler ile konumuzu pekiştirebiliriz.\n" }, { "path": "web-sunucu-server-ag-istemleri/rabbitmq/basitce-rabbitmq-kullanimi.md", "content": "# Basitçe RabbitMQ Kullanımı\n\nProje yapımız bu şekilde olacak.\n\n```\n├── consumer\n│ └── consumer.go\n├── go.mod\n├── go.sum\n└── producer\n └── producer.go\n```\n\nÖğrenirken rahatlık olması açısından önden proje yapısını bu şekilde oluşturabilirsiniz.\n\nGo üzerinde RabbitMQ'yu kullanabilmek için gerekli olan paketimizi kuralım.\n\n`go get github.com/streadway/amqp`\n\n`producer.go` isminde bir dosya oluşturalım. Bu dosyamız RabbitMQ'ya mesaj gönderen kodlarımızı barındıracak.\n\n{% code title=\"producer.go\" %}\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"log\"\n\n\t\"github.com/streadway/amqp\"\n)\n\nfunc main() {\n\t//Önce RabbitMQ sunucumuzla bağlantı kuralım.\n\tconn, err := amqp.Dial(\"amqp://guest:guest@localhost:5672/\")\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\tdefer conn.Close()\n\n\t//Mesajımızı göndermek için bir kanal oluşturalım.\n\tch, err := conn.Channel()\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\tdefer ch.Close()\n\n\t//Mesajımızı göndereceğimiz kuyruğu tanımlayalım.\n\tkuyruk, err := ch.QueueDeclare(\n\t\t\"kuyruk1\", // kuyruğumuzun ismi\n\t\tfalse, // durable\n\t\tfalse, // delete when unused\n\t\tfalse, // exclusive\n\t\tfalse, // no-wait\n\t\tnil, // arguments\n\t)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\n\tmesajımız := \"Hello World!\"\n\n\t//Mesajımızı paylaşmak için yapmamız gerekenler\n\terr = ch.Publish(\n\t\t\"\", // exchange\n\t\tkuyruk.Name, // Gönderilecek kuyruk ismi. Bu şekilde önceki oluşturduğumuz kuyruğun ismini alabiliriz\n\t\tfalse, // mandatory\n\t\tfalse, // immediate\n\t\tamqp.Publishing{\n\t\t\tContentType: \"text/plain\", //mesajımızın tipi\n\t\t\tBody: []byte(mesajımız),\n\t\t})\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\n\tfmt.Println(\"Mesajımız başarılı bir şekilde gönderildi!\")\n\n}çgo\n```\n{% endcode %}\n\nYorum satırı olarak yaptığım açıklamalar dışında ek olarak inceleyelim.\n\n`amqp.Dial()` fonksiyonu içerisinde ayağa kaldırdığımız RabbitMQ servisine bağlanmak için gerekli olan bilgileri girdik.\n\nDaha sonra RabbitMQ servisimizle iletişimde bulunmak için kanal oluşturduk.\n\nMesajımızı bir kuyruğa göndereceğimiz için kuyruk oluşturduk ve bu kuyruğa `kuyruk1` ismini verdik. Aslında bu işlemlerde çok fazla detay var ama basit kullanımını göstermek için özetle anlatıyor olacağım.\n\n`Publish()` fonksiyonu içerisinde mesajımızı göndereceğimiz ayarlamaları yaptık.\n\n`amqp.Publishing{}` yapısında göndereceğimizi içeriğin tipini belirttik ve mesajımızı byte dizisine çevirerek gönderdik.\n\nBu şekilde `kuyruk1` isimli kuyruğumuza `\"Hello World!\"` yazısını gönderdik ve bu yazımız kuyrukta bekliyor.\n\nProgramımızı her çalıştırdığımızda kuyruğumuza mesajımız bir kez daha eklenecektir.\n\nEğer RabbitMQ panelinden görmek isterseniz, [http://localhost:15672](http://localhost:15672) adresinden girişi yaparak gözlemleyebilirsiniz.\n\nVarsayılan olarak `Username` ve `Password` kısımlarına `guest` yazarak panele giriş yapabilirsiniz.\n\nOluşturduğumuz kuyruğu incelemek için `Queues` sekmesine bakabilirsiniz.\n\n![](<../../.gitbook/assets/Screen Shot 2022-05-06 at 22.26.18.png>)\n\nReady sütununda işlenmeye hazır bekleyen 7 adet mesajımızın olduğunu görebilirsiniz. Çünkü `producer` kodlarımızı 7 defa çalıştırdım. Böylelikle RabbitMQ'ya 7 defa mesaj göndermiş oldu. Tablomuz ne kadar süper anlık olmasa da elinden geldiğince anlık bilgileri vermeye çalışıyor :smile:\n\nMesajlarımız `kuyruk1`'de birikti. Şimdi bu mesajlarımızı sıra sıra alacak bir `consumer` oluşturalım.\n\nÖnce `consumer.go` isimli bir dosya oluşturalım.\n\n{% code title=\"consumer.go\" %}\n```go\npackage main\n\nimport (\n\t\"log\"\n\n\t\"github.com/streadway/amqp\"\n)\n\nfunc main() {\n\t//RabbitMQ Sunucumuza bağlanıyoruz\n\tconn, err := amqp.Dial(\"amqp://guest:guest@localhost:5672/\")\n\tdefer conn.Close()\n\n\t//İletişim kurabilmek için kanal oluşturalım\n\tch, err := conn.Channel()\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\tdefer ch.Close()\n\n\t//Kuyruğumuzu tanımlıyoruz\n\t_, err = ch.QueueDeclare(\n\t\t\"kuyruk1\", // name\n\t\tfalse, // durable\n\t\tfalse, // delete when unused\n\t\tfalse, // exclusive\n\t\tfalse, // no-wait\n\t\tnil, // arguments\n\t)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\n\t//İşte burada kuyruğumuzu dinliyoruz.\n\tmsgs, err := ch.Consume(\n\t\t\"kuyruk1\", // Bu sfer dinleyeceğim kuyruk ismini kendim yazdım\n\t\t\"\", // consumer\n\t\ttrue, // auto-ack\n\t\tfalse, // exclusive\n\t\tfalse, // no-local\n\t\tfalse, // no-wait\n\t\tnil, // args\n\t)\n\tif err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\t//Burada goroutine ile çalışan fonksiyonumuz\n\t//çalışırken programın kapanmaması için\n\t//kanal oluşturduk\n\tforever := make(chan bool)\n\n\tgo func() {\n\t\t//Burada eğer varsa kuyruktaki mesajları çekiyoruz\n\t\tfor d := range msgs {\n\t\t\t//d değişkeni ile kuyruktaki mesajın bilgilerine ulaşabiliriz.\n\t\t\tlog.Printf(\"Alınan mesaj: %s\", d.Body)\n\t\t\t//Kuyruktaki mesaj ekrana bastırdık.\n\t\t}\n\t}()\n\n\tlog.Printf(\" [*] Kuyruk1 dinleniyor...\")\n\n\t//Burada forever isimli kanalımıza değer gönderilmeyeceği için\n\t//programımız kapanmayacak ve sürekli olarak kuyruktaki mesajları çekecektir.\n\t<-forever\n}\n\n```\n{% endcode %}\n\nDetaylıca incelersek;\n\n`consumer.go` içerisinde yeniden kuyruğumuz yani `kuyruk1`'in tanımlamasını yaptık. Aslında kuyruğumuzu producer kodlarında zaten tanımlamıştık. Peki burada neden yeniden kuyruk tanımlaması yaptığımızı açıklayalım.\n\n`consumer.go`'da kuyruk tanımlaması yapmadan çalıştırırsak, `Consume()` fonksiyonunda kuyruk ismini belirterek dinleme yapmamız mümkündür. Fakat RabbitMQ sunucusunu yeniden başlattığımızda `kuyruk1` isimli kuyruğun silindiğini göreceksiniz. Kuyruk tanımlaması yapmazsak `consumer.go` dosyamız çalıştırıldığında `kuyruk1` isimli bir kuyruk olmadığı hatasını verecektir. Bunun için işimizi garantiye alıp kuyruğumuzu tanımlıyoruz. Yani producer oluşturmadıysa consumer'ın kuyruğu oluşturmasını sağlıyoruz.\n\nYukarıdaki consumer örneğimizde, gelen mesajı ekrana bastırmak yerine uzun sürecek bir işlem yapabilirdik ki, zaten RabbitMQ'nun en çok kullanılan alanlarından biri de uzun süren işlemlerdir.\n\nFakat örnekte direkt olarak bir sonuç görmek ve başka alanlara sapmamak için basit olarak nasıl çalıştığını gösterdim.\n" }, { "path": "web-sunucu-server-ag-istemleri/rabbitmq/rabbitmq-kurulumu.md", "content": "# RabbitMQ Kurulumu\n\nHerşeyden önce bize bir RabbitMQ sunucusu lazım. Bunun için [bu adresten](https://www.rabbitmq.com/#getstarted) RabbitMQ'yu indirebilirsiniz.\n\nİsterseniz benim de sıkça kullanıdığım gibi bir Heroku hesabınız var ise RabbitMQ'yu ücretsiz olarak eklenti olarak kullanabiliriz.\n\nSunucumuzu ayağa kaldırmak için aşağıdaki komutu kullanalım.\n\n```\nrabbitmq-server\n```\n\n`Starting broker... completed with 7 plugins.` mesajını görürsek başarılı bir şekilde çalışıtığını görebiliriz.\n\nRabbitMQ sunucumuzu yerel makinamızda ayağa kaldırdıysak varsayılan olarak aşağıdaki bilgiler ile erişilebilir olacaktır.\n\n`amqp://guest:guest@localhost:5672/`\n" }, { "path": "web-sunucu-server-ag-istemleri/requests.md", "content": "# HTTP İstekleri (Requests)\n\nBu bölümde bir web sayfasına nasıl istekte bulunacağımızı göreceğiz.\n\n## Get İsteği\n\nStandart istektir.\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n)\n\nfunc main() {\n\t//Google anasayfasına GET isteğinde bulunalım\n\t//ve dönen cevabı cevap değişkenine atayalım\n\tcevap, hata := http.Get(\"https://www.google.com.tr\")\n\tif hata != nil {\n\t\t//Ya sev ya terket dedik ve paniği bastık.\n\t\tpanic(hata)\n\t}\n\t//Body'i kapatmayı unutmayalım\n\tdefer cevap.Body.Close()\n\n\t//Bu esnada Body'den cevabı çekip sayfa değişkenine alıyoruz.\n\t//Çünkü bunu yapmadan okunabilir bir sonuç alamayız.\n\tsayfa, hata := io.ReadAll(cevap.Body)\n\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\t//sayfa değişkeni byte dizisi tipinde olduğu için\n\t//string tipine cevirip okuyalım\n\tfmt.Println(string(sayfa))\n\n\t//Çıktımız Google TR anasayfasının kaynak kodları olacaktır.\n}\n```\n\n### Sorgu Parametresi Ekleme\n\nÖrneğin, yaptığımız istekte `search?q=golang&hl=de` gibi bir sorgu kısmı olmasını istiyoruz. URL'yi girdiğimiz kısmı bunu el ile ekleyebiliriz tabiki. Ama onunda kolay bir yöntemi var. Bunun için `net/url` paketini içe aktaralım. Hemen görelim.\n\n```go\nfunc main() {\n\tparams := url.Values{\n\t\t\"q\": {\"golang\"}, //aranacak metin\n\t\t\"hl\": {\"tr\"}, //örnek olarak Türkçe sonuç vermesi için\n\t}\n\tfmt.Println(\"https://www.google.com.tr/search?\" + params.Encode())\n}\n```\n\nÇıktımız: `https://www.google.com.tr/search?q=golang&hl=tr`\\\nolacaktır.\n\nBu örneği de aşağıdaki gibi kullanabilirsiniz.\n\n```go\npackage main\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"net/url\"\n)\n\nfunc main() {\n\tparams := url.Values{\n\t\t\"q\": {\"golang\"},\n\t\t\"hl\": {\"tr\"},\n\t}\n\n\t//URL'imizi aşağıdaki gibi yazalım.\n\tcevap, hata := http.Get(\"https://www.google.com.tr/search?\" + params.Encode())\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\tdefer cevap.Body.Close()\n\n\tsayfa, hata := io.ReadAll(cevap.Body)\n\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\tfmt.Println(string(sayfa))\n\n}\n```\n\n## Postform İsteği\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"net/url\"\n)\n\nfunc main() {\n\t//URL'e gönderilecek verileri oluşturalım.\n\tdeğerler := url.Values{\n\t\t\"isim\": {\"Kaan\"},\n\t\t\"soyisim\": {\"Kuşcu\"},\n\t}\n\n\t//değerler.Encode() yapmadan direkt değerler şekline gönderiyoruz\n\t//çünkü göndereceğimiz bir url parametresi değildir.\n\tcevap, hata := http.PostForm(\"https://orneksite.com/kisiler\", değerler)\n\n\t//Ya sev ya terket\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\t//Body'i kapatmayı unutmuyoruz.\n\tdefer cevap.Body.Close()\n\n\t//Body'den gelen veriyi okuyoruz.\n\tsonuç, hata := io.ReadAll(cevap.Body)\n\n\t//Ya sev...\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\t//İnsanlar byte dizisini okuyamadığı için\n\t//string tipine çeviriyoruz.\n\tfmt.Println(string(sonuç))\n}\n```\n\n## Post İsteği\n\nPost isteğini yaparken örnek bir json verisi göndermeyi görelim.\n\n```go\npackage main\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n)\n\nfunc main() {\n\taddress := \"https://orneksite.com/kisiler\"\n\thamVeri := map[string]string{\n\t\t\"isim\": \"Kaan\",\n\t\t\"soyisim\": \"Kuşcu\",\n\t}\n\tjsonVeri, hata := json.Marshal(hamVeri)\n\t//jsonVeri string tipine çevirildiğinde:\n\t//{\"isim\":\"Kaan\",\"soyisim\":\"Kuşcu\"}\n\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\t//Aşağıdaki gönderdiğimiz verinin json tipinde olduğunu bildiriyoruz.\n\tsorgu, hata := http.Post(address, \"application/json\", bytes.NewBuffer(jsonVeri))\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\t//sonucu sonuç değişkenine atayalım\n\tsonuç, hata := io.ReadAll(sorgu.Body)\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\t//Son olarak ekrana bastıralım.\n\tfmt.Println(string(sonuç))\n}\n```\n\nYukarıdaki örnekte json verimizi `map` ile oluşturarak `post` isteğinde kullandık. Map ile oluşturduğumuz json verisi esnek olmadığı için, yani yukarıdaki örnekte sadece `string` tipinde veri oluşturabildiğimiz için, bir de `struct` ile oluşturmayı görelim. Anonim bir struct oluşturup işimizi görebiliriz.\n\n```go\npackage main\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n)\n\nfunc main() {\n\taddress := \"https://orneksite.com/kisiler\"\n\n\t//struct içindeki değişken isimlerini büyük harfle\n\t//yazmazsak json'a çevirirken hata alırız.\n\tstructVeri := struct {\n\t\tİsim string `json:\"isim\"` //json'da isim olacak\n\t\tSoyisim string `json:\"soyisim\"` //json'da soyisim olacak\n\t\tYaş int `json:\"yas\"` //json'da yas olacak\n\t}{\"Kaan\", \"Kuşcu\", 23}\n\n\t//struct'ımızı json'a çevirelim.\n\tjsonVeri, hata := json.Marshal(structVeri)\n\t//jsonVeri string tipine çevirildiğinde:\n\t//{\"isim\":\"Kaan\",\"soyisim\":\"Kuşcu\",\"yas\":23}\n\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\t//Aşağıdaki gönderdiğimiz verinin json tipinde olduğunu bildiriyoruz.\n\tsorgu, hata := http.Post(address, \"application/json\", bytes.NewBuffer(jsonVeri))\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\t//sonucu sonuç değişkenine atayalım\n\tsonuç, hata := io.ReadAll(sorgu.Body)\n\tif hata != nil {\n\t\tpanic(hata)\n\t}\n\n\t//Son olarak ekrana bastıralım.\n\tfmt.Println(string(sonuç))\n}\n```\n\n![](../.gitbook/assets/EvYnc-5VoAEOSTV.jpeg)\n" }, { "path": "web-sunucu-server-ag-istemleri/statik-kuetuephanesi-ile-dosyalari-uygulamaya-goemme.md", "content": "# Statik Kütüphanesi ile Dosyaları Uygulamaya Gömme\n\nGolang’ın müthiş yanlarından biri de bir uygulamayı build ettiğimizde bize tek çalıştırılabilir dosya şeklinde sunmasıdır. Fakat bu özellik sadece **.go** dosyalarını birleştirilmesinde kullanılıyor. Harici dosyalar programa gömülmüyor. Fakat **Statik** isimli kütüphane ile bu işlem mümkün kılınıyor.\\\nKütüphanenin mantığından kısaca bahsedeyim. Belirlediğiniz bir dizindeki dosyaları bir kodlamaya çevirerek programın içine dosya gömmek yerine kod gömüyor. Ve bu kodu sanki dosyaymışcasına kullanabiliyoruz. Tabi ki sadece sunucu işlemlerinde işe yarar olduğunu belirtelim.\\\nBu yöntemin güzel artı yönleri var.\n\n* Programımız tek dosya halinde kalıyor.\n* Programımız kapalı kaynak oluyor.\n\nTanıtımını yaptığımıza göre hafiften uygulamaya başlayalım.\n\n> go get github.com/rakyll/statik\n\nKonsola yukarıdakini yazarak kütüphanemizi indiriyoruz. Öncelikle dosya ve klasör yapımızı aşağıdaki gibi ayarlıyoruz.\n\n![Proje klasörümüzün dizin düzeni](../.gitbook/assets/statik.png)\n\nKodlamaya dönüştürülmesini istediğimiz klasör ile işlem yapıyoruz. Yani **public** klasörü ile. Aşağıdaki komutu **Proje klasörümüz** içerisindeyken yazıyoruz.\n\n> statik -src=/public/klasörünün/adresi -f\n\nBu işlemle birlikte **public** klasörümüzün yanına statik isimli bir klasör oluşturduk ve içine **statik.go** isimli dosya oluşturmuş olduk. Bu dosyanın içerisinde bizim **public** klasörümüzün kodlanmış hali mevcuttur.\\\nVe sırada **main.go** dosyamızı oluşturmakta. Aşağıdaki kodlarıda **main.go** dosyamıza yazıyoruz.\n\n```go\npackage main\nimport (\n \"net/http\"\n \"github.com/rakyll/statik/fs\"\n _ \"./statik\" //Oluşturulmuş statik.go dosyasının konumu\n)\nfunc main() {\n statikFS, _ := fs.New()\n http.Handle(\"/\", http.StripPrefix(\"/\", http.FileServer(statikFS)))\n http.ListenAndServe(\":5555\", nil)\n}\n```\n\nGerekli kütüphanelerimizi ekledikten sonra **main()** fonksiyomuzun içeriğini inceleyelim.\n\n**statikFS** ve **\\_** adında değişkenlerimizi tanımladık. Bu değişkenlerimizi fonksiyonel değişkendir. **\\_** koymamızın sebebi **error** çıktısını kullanmak istemediğimizdendir. Eğer lazım olursa kullanabilirsiniz. **fs.New()** diyerek **statikFS** değişkenimizi bir dosya sistemi olarak tanıttık. Daha sonra sunucu oluşturak anadizine ulaşılmak istendiğinde oluşturduğumuz dosya sistemine bağlanmasını sağladık. Artık dosya sistemimize **localhost:5555** üzerinden ulaşılabilir oldu.\n" }, { "path": "yapilandirma/viper.md", "content": "---\ncoverY: 0\n---\n\n# 🐍 Viper\n\n
\"\"

Viper logo

\n\n## Viper nedir?\n\nViper, [12-Factor uygulamaları](https://12factor.net/) da dahil olmak üzere Go uygulamaları için eksiksiz bir yapılandırma çözümüdür. Bir uygulama içinde çalışmak üzere tasarlanmıştır. Her türlü yapılandırma gereksinimini ve biçimini karşılayabilir.\n\nDesteklediği yöntemler şunlardır:\n\n* varsayılanları ayarlama,\n* JSON, TOML, YAML, HCL, envfile ve Java properties config dosyalarından okuma,\n* yapılandırma dosyalarını canlı izleme ve yeniden okuma (opsiyonel),\n* ortam değişkenlerinden okuma,\n* uzak yapılandırma sistemlerinden (etcd ya da Consul) okuma ve canlı izleme,\n* komut-satırı flag'lerinden okuma,\n* buffer'dan okuma,\n* açık değerler atama.\n\nViper, tüm uygulama yapılandırma ihtiyaçlarınız için bir kayıt defteri olarak düşünülebilir.\n\n## Nasıl kullanılır?\n\nBu kısımda, `json` tipinde bir yapılandırma dosyası üzerinden, yapılandırmamızı nasıl yönetebileceğimizi `(okuma, yazma...)` göreceğiz.\n\n\n\nÖncelikle projemizi oluşturalım.\n\n```\ngo mod init \n```\n\ndaha sonra ihtiyacımız olduğu için `main.go` ve `config.json` isimli dosyalarımızı oluşturalım. Sonuç olarak projemizin içeriği aşağıdaki gibi olacak.\n\n{% code title=\"$ tree .\" %}\n```\n.\n├── config.json\n├── go.mod\n├── go.sum\n└── main.go\n```\n{% endcode %}\n\n#### Viper paketini kuralım\n\n```\ngo get github.com/spf13/viper\n```\n\n`config.json` dosyamızda aşağıdaki gibi bir yapı oluşturalım.\n\n{% code title=\"config.json\" %}\n```json\n{\n \"host\": \"127.0.0.1\",\n \"port\": \"80\"\n}\n```\n{% endcode %}\n\nArtık `config.json` dosyamızı `host` ve `port` değerlerini okuyup yazmak için kullanabiliriz.\n\n`main.go` dosyamızın içeriği de aşağıdaki gibi olsun.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"github.com/spf13/viper\"\n\t\"log\"\n)\n\nfunc main() {\n\tvp := viper.New() // yeni bir viper örneği oluşturalım\n\n\tvp.AddConfigPath(\".\") // config dosyamızın bulunduğu dizin\n\tvp.SetConfigName(\"config\") // config dosyamızın ismi\n\tvp.SetConfigType(\"json\") // config dosyamızın uzantısı\n\n\tif err := vp.ReadInConfig(); err != nil {\n\t\tlog.Fatalf(\"yapılandırma dosyası okunurken hata oluştu: %v\", err)\n\t}\n}\n```\n{% endcode %}\n\nYukarıdaki yöntem ile oluşturduğumuz yapılandırma dosyasının içeriğini artık yönetebiliriz.\n\nHadi nasıl okuyacağımıza bakalım.\n\n```go\nvp.Get(\"host\") // 127.0.0.1\n```\n\n`Get()` fonksiyonu ile belirli bir anahtarın değerini okuyabiliriz. Burada dikkat edilmesi gereken nokta `Get()` fonksiyonu bize `any` tipinde bir değer döndürür. Döndürülen bu değeri asıl tipine çevirmeden kullanamayacağımız durumlar olabilir. Bu durumlarda **type assertion** yaparak değeri çıkartabiliriz ;fakat daha kolay bir yöntem olarak `GetString()` fonksiyonunu kullanabiliriz\n\n```go\nvp.GetString(\"host\") // 127.0.0.1\n```\n\nTabi ki bu yöntem sadece `string` tipi için geçerli değil, hepsine tek tek değinmek uzun süreceği için direkt olarak dönüştürebileceğimiz tiplere kısa değinelim.\n\n```go\nbool\n\nstring, []string, map[string]interface{}, map[string]string{}, map[string][]string{}\n\nint, int32, int64, []int\n\nuint, uint16, uint32, uint64\n\nfloat64\n\ntime.Time, time.Duration\n```\n\nYukarıda verilen tipler için ilgili fonksiyonu `Get()` yazarak bulabilirsiniz. Bu şekilde kullanamadığınız tipleri de **type assertion** yaparak dönüştürebilirsiniz.\n\n\n\nŞimdi de yapılandırma dosyamızdaki bir anahtara nasıl atama yapacağımıza bakalım.\n\n```go\nvp.Set(\"host\", \"example.com\") // atama işlemi\n\n// değişiklikleri yapılandırma dosyasına yazdıralım\nif err := vp.WriteConfig(); err != nil {\n log.Fatalf(\"yapılandırma dosyası yazılırken hata oluştu: %v\", err)\n}\n```\n\nYazdırma işleminde sonra `config.json` dosyamız aşağıdaki gibi değişecektir.\n\n{% code title=\"config.json\" %}\n```json\n{\n \"host\": \"example.com\",\n \"port\": \"80\"\n}\n```\n{% endcode %}\n\nAtama işlemini eğer var olmayan bir anahtar ile yapsaydık, yeni bir alan oluştururduk. Örnek:\n\n```go\nvp.Set(\"user\", \"kaan\")\n```\n\nYapılandırma dosyamızdaki değişikliğe bakalım.\n\n{% code title=\"config.json\" %}\n```json\n{\n \"host\": \"example.com\",\n \"port\": \"80\",\n \"user\": \"kaan\"\n}\n```\n{% endcode %}\n\n{% hint style=\"info\" %}\nAnahtar değerinin boş olarak atanması veya silinmesi gibi işlemler uygulamanın kararsız çalışmasına neden olabileceği için bu tür fonksiyonların kullanımını engellemişler. Zaten anahtarın silinmesi için bir fonksiyon bulunmamaktadır. Bu yüzden viper paketinin kullanımı sadece `Set` ve `Get` işlemlerini destekler.\n{% endhint %}\n\n`WriteConfig()` fonksiyonu dosyanın yazılmasında karşılaşılan hataları döndürür.\n\n### Yapılandırma dosyasını oluşturma\n\nYapılandırma dosyasının uygulamamız tarafından oluşturulmasını istediğimiz durumlar olabilir. Bu durumlarda, yukarıdaki örneklerimizde gördüğümüzün aksine yapılandırma dosyamızı okumadan önce oluşturmamız gerekir.\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"github.com/spf13/viper\"\n\t\"log\"\n)\n\nfunc main() {\n\tvp := viper.New() // yeni bir viper örneği oluşturalım\n\n\tvp.AddConfigPath(\".\") // config dosyamızın bulunduğu dizin\n\tvp.SetConfigName(\"config\") // config dosyamızın ismi\n\tvp.SetConfigType(\"json\") // config dosyamızın uzantısı\n\n\tvp.Set(\"host\", \"example.com\")\n\tvp.Set(\"port\", \"80\")\n\n\t// değişiklikleri oluşturmak istediğimiz yapılandırma dosyasına yazdıralım\n\tif err := vp.WriteConfig(); err != nil {\n\t\tlog.Fatalf(\"yapılandırma dosyası yazılırken hata oluştu: %v\", err)\n\t}\n}\n```\n{% endcode %}\n\n`WriteConfig()` fonksiyonunda dikkat edilmesi gereken ayrıntı, eğer oluşturulan yapılandırma dosyası hali hazırda bulunuyorsa bu dosyanın üzerine yazar, fakat üzerine yazma işleminde belirtilmemiş olan anahtarlar eski yapılandırma dosyasındaki hali ile gelir. Yani yapılandırma dosyası tamamen sıfırdan oluşturulmaz.\n\nEğer yapılandırma dosyamızın oluşturulduktan sonra bir daha değiştirilmemesini ve sadece hali hazırda bulunmadığı durumlarda oluşturulmasını istersek `SafeWriteConfig()` fonksiyonunu kullanabiliriz. Böylelikle yapılandırma dosyamız zaten oluşturulmuşsa bize hata döndürecektir.\n\nÖrnek olarak:\n\n{% code title=\"main.go\" %}\n```go\npackage main\n\nimport (\n\t\"github.com/spf13/viper\"\n\t\"log\"\n)\n\nfunc main() {\n\tvp := viper.New() // yeni bir viper örneği oluşturalım\n\n\tvp.AddConfigPath(\".\") // config dosyamızın bulunduğu dizin\n\tvp.SetConfigName(\"config\") // config dosyamızın ismi\n\tvp.SetConfigType(\"json\") // config dosyamızın uzantısı\n\n\tvp.Set(\"host\", \"example.com\")\n\tvp.Set(\"port\", \"80\")\n\n\t// değişiklikleri oluşturmak istediğimiz yapılandırma dosyasına yazdıralım\n\tif err := vp.SafeWriteConfig(); err != nil {\n\t\tlog.Fatalf(\"yapılandırma dosyası yazılırken hata oluştu: %v\", err)\n\t}\n}\n```\n{% endcode %}\n\n`config.json` dosyamız bulunmuyorsa, atanılan değerler ile birlikte yeni bir `config.json` dosyası oluşturulacaktır. Eğer `config.json` dosyamız bulunuyorsa, yukarıdaki işlemler yapıldığında `SafeWriteConfig()` fonksiyonu aşağıdaki gibi bir hata döndürecektir.\n\n{% code title=\"$ go run .\" %}\n```\n2022/10/06 17:50:56 yapılandırma dosyası yazılırken hata oluştu: Config File \"/Volumes/SAMSUNG/main/Dev/go/viper-example/config.json\" Already Exists\n```\n{% endcode %}\n\nEğer yapılandırma dosyamız iç içe bir yapıdan oluşuyorsa, okuma-yazma işlemlerinde alt-alana ulaşmak için `.` _(nokta)_ kullanabiliriz.\n\nÖrnek config.json dosyamız;\n\n{% code title=\"config.json\" %}\n```json\n{\n \"user\": {\n \"full_name\": \"Kaan Kuscu\",\n \"age\": 25\n }\n}\n```\n{% endcode %}\n\nOkuma işlemi için,\n\n```go\nvp.Get(\"user.full_name\") // Kaan Kuscu\n```\n\nYazma işlemi de aynı şekilde,\n\n```go\nvp.Set(\"user.full_name\") // Kaan Kuscu\n```\n\n### Ortam Değişkenleri ile kullanımı\n\nUygulamayı çalıştırdığımız sistemimizdeki ortam değişkenlerine erişmek istediğimizde, başvurabileceğimiz iki farklı yöntem var.\n\nBu yöntemlerden ilki kullanmak istediğimiz ortam değişkenini viper'a bildirmek. Örneğin `TEST` isminde bir ortam değişkenimiz olsun ve değeri de `abc` olsun. `TEST`'in değerini okuyabilmek için aşağıdaki yöntemleri kullanabiliriz.\n\n```go\nif err := vp.BindEnv(\"TEST\"); err != nil {\n log.Fatalln(err)\n}\n\nfmt.Println(vp.Get(\"TEST\"))\n```\n\nSisteminizde `TEST` isimli bir ortam değişkeni bulunmuyorsa, aşağıdaki gibi deneyebilirsiniz.\n\n{% code title=\"$ TEST=\"abc\" go run .\" %}\n```\nabc\n```\n{% endcode %}\n\n`BindEnv()` fonksiyonunun hata döndürmeme şartı sadece en az bir parametre girmemizdir.\n\n### Varsayılan değerleri atama\n\nYapılandırma dosyaların ve ortam değişkenlerinden okuma yaptığımızda, bazı anahtarlar tanımlı olmadığı için, sıfır-değerli halde gelebilir. Eğer bu istemediğimiz bir durumsa bu anahtarların varsayılan değerlerini ayarlayabiliriz. Örnek;\n\n{% code title=\"config.json\" %}\n```json\n{\n \"host\": \"localhost\",\n \"port\": \"80\",\n \"user\": \"root\"\n}\n```\n{% endcode %}\n\nGelelim kullanımına;\n\n```go\nif err := vp.ReadInConfig(); err != nil {\n\tlog.Fatalln(err)\n}\n\nvp.SetDefault(\"password\", \"1234\") // anahtar, değer\n\nfmt.Println(vp.GetString(\"password\")) // 1234\n```\n\n`config.json` dosyamızda `password` isimli bir alan olmadığı için varsayılan olarak ayarladığımız `1234` değeri yazdırılacaktır.\n\nEğer varsayılan değerler çok sayıda olacaksa, şöyle bir yöntem kullanabiliriz.\n\n```go\ndefaults := map[string]any{\n\t\"host\": \"localhost\",\n\t\"user\": \"root\",\n\t\"password\": \"1234\",\n}\n\t\nfor k, v := range defaults {\n\tvp.Set(k, v)\n}\n```\n\n### Unmarshal\n\nBuraya kadar olan bölümlerde Viper'ı basitçe nasıl kullanacağımızı gördük. Ölçeklenebilir bir projede sadece bu yöntemleri kullarak ilerlememiz zor olduğu için işimizi kolaylaştıracak başka çözümler gerekiyor. Proje yapımızı düzenli tutmak için, bu yöntemlerimizi daha pratik hale getirmemiz gerekiyor.\n\nBunun için gruplandırma yaparak, yapılandırma ayarlarımızı `struct` halinde kullanabiliriz.\n\nÖrneğin aşağıdaki gibi bir yapılandırma dosyamız olsun.\n\n{% code title=\"config.json\" %}\n```json\n{\n \"api\": {\n \"host\": \"example.com\",\n \"port\": \"80\",\n \"ssl\": true\n },\n \"database\": {\n \"host\": \"localhost\",\n \"user\": \"root\",\n \"password\": \"1234\",\n \"name\": \"project\"\n }\n}\n```\n{% endcode %}\n\nYukarıdaki `json` yapısı aktarabileceğimiz `struct`'ları belirleyelim.\n\n```go\ntype Config struct {\n\tAPI APIConfig `mapstructure:\"api\"`\n\tDatabase DataBaseConfig `mapstructure:\"database\"`\n}\n\ntype APIConfig struct {\n\tHost string `mapstructure:\"host\"`\n\tPort string `mapstructure:\"port\"`\n\tSSL bool `mapstructure:\"ssl\"`\n}\n\ntype DataBaseConfig struct {\n\tHost string `mapstructure:\"host\"`\n\tUser string `mapstructure:\"user\"`\n\tPassword string `mapstructure:\"password\"`\n\tName string `mapstructure:\"name\"`\n}\n```\n\nYukarıdaki `struct`'larda dikkat edilmesi gereken ayrıntı, `struct tag`'lerdeki `mapstructure` anahtarıdır.\n\nYapılandırma dosyamızın tipi `json` olduğu için `mapstructure` yerine `json`'da kullanabilirdik. Fakat yapılandırma dosyamızın tipi, örnek olarak `json`'dan `yaml`'a geçseydi, `struct tag`'lerde `yaml` olarak düzenleme yapmamız gerekirdi. Bu yüzden tüm desteklenen yapılandırma dosyası tiplerinde unmarshal yapabilmesi için `mapstructure` olarak uyguladık.\n\n{% hint style=\"info\" %}\nTabi ki bu yöntem her durumda işimizi görmeyebilir. Bazı durumlarda farklı dosya tiplerinde farklı anahtar isimlendirmeleri olabilir. Bu gibi durumlarda da dosya tipine göre `struct tag`'lerini düzenlemekte fayda vardır.\n{% endhint %}\n\n`Unmarshal` etmek için aşağıdaki yöntemi izleyebiliriz.\n\n{% code title=\"main.go\" %}\n```go\nfunc main() {\n\tvp := viper.New()\n\n\tvp.AddConfigPath(\".\")\n\tvp.SetConfigName(\"config\")\n\tvp.SetConfigType(\"json\")\n\n\t// öncelikle yapılandırma dosyasını okumamız gerekiyor\n\tif err := vp.ReadInConfig(); err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\t\n\tvar configs Config\n\n\tif err := vp.Unmarshal(&configs); err != nil {\n\t\tlog.Fatalln(err)\n\t}\n\n\tfmt.Printf(\"%+v\\n\", configs)\n}\n```\n{% endcode %}\n\nÇıktımız aşağıdaki gibi olacaktır.\n\n{% code title=\"$ go run .\" %}\n```\n{API:{Host:example.com Port:80 SSL:true} Database:{Host:localhost User:root Password:1234 Name:project}}\n```\n{% endcode %}\n" } ]