ورود به حساب

نام کاربری گذرواژه

گذرواژه را فراموش کردید؟ کلیک کنید

حساب کاربری ندارید؟ ساخت حساب

ساخت حساب کاربری

نام نام کاربری ایمیل شماره موبایل گذرواژه

برای ارتباط با ما می توانید از طریق شماره موبایل زیر از طریق تماس و پیامک با ما در ارتباط باشید


09117307688
09117179751

در صورت عدم پاسخ گویی از طریق پیامک با پشتیبان در ارتباط باشید

دسترسی نامحدود

برای کاربرانی که ثبت نام کرده اند

ضمانت بازگشت وجه

درصورت عدم همخوانی توضیحات با کتاب

پشتیبانی

از ساعت 7 صبح تا 10 شب

دانلود کتاب Rust Essentials

دانلود کتاب Rust Essentials

Rust Essentials

مشخصات کتاب

Rust Essentials

ویرایش: 2nd edition 
نویسندگان:   
سری:  
ISBN (شابک) : 9781788390019, 1788399137 
ناشر: Packt Publishing 
سال نشر: 2017 
تعداد صفحات: 257 
زبان: English 
فرمت فایل : PDF (درصورت درخواست کاربر به PDF، EPUB یا AZW3 تبدیل می شود) 
حجم فایل: 3 مگابایت

قیمت کتاب (تومان) : 49,000



کلمات کلیدی مربوط به کتاب Rust Essentials: خوردگی و ضد خوردگی,کتاب های الکترونیکی



ثبت امتیاز به این کتاب

میانگین امتیاز به این کتاب :
       تعداد امتیاز دهندگان : 14


در صورت تبدیل فایل کتاب Rust Essentials به فرمت های PDF، EPUB، AZW3، MOBI و یا DJVU می توانید به پشتیبان اطلاع دهید تا فایل مورد نظر را تبدیل نمایند.

توجه داشته باشید کتاب Rust Essentials نسخه زبان اصلی می باشد و کتاب ترجمه شده به فارسی نمی باشد. وبسایت اینترنشنال لایبرری ارائه دهنده کتاب های زبان اصلی می باشد و هیچ گونه کتاب ترجمه شده یا نوشته شده به فارسی را ارائه نمی دهد.


توضیحاتی در مورد کتاب Rust Essentials

از برنامه نویسی کاربردی و ویژگی های همزمان Rust استفاده کنید و توسعه برنامه خود را سرعت دهید درباره این کتاب با Rust شروع کنید تا برنامه های کاربردی مقیاس پذیر و با کارایی بالا ایجاد کنید. و نرم افزار مقیاس پذیر Who This Book Is For این کتاب برای توسعه دهندگانی است که به دنبال ورود سریع به استفاده از Rust و درک ویژگی های اصلی زبان هستند. دانش برنامه نویسی پایه فرض شده است. آنچه یاد خواهید گرفت محیط Rust خود را برای دستیابی به بالاترین بهره وری تنظیم کنید شکاف عملکرد بین زبان های ایمن و ناامن را پر کنید از تطبیق الگو برای ایجاد کد انعطاف پذیر استفاده از کلیات و ویژگی ها برای ایجاد کدهای کاربردی به طور گسترده سازماندهی کد خود را در ماژول ها و جعبه ها بسازید ماکروها برای گسترش توانایی ها و دسترسی Rust اعمال وظایف برای مقابله همزمان با مشکلات در یک محیط توزیع شده In Detail Rust زبان برنامه نویسی سیستم های جدید، منبع باز، سریع و ایمن برای قرن بیست و یکم است که در تحقیقات موزیلا و با جامعه ای به طور پیوسته در حال رشد توسعه یافته است. این برای حل معضل بین کدهای سطح بالا و آهسته با حداقل کنترل روی سیستم و کدهای سطح پایین و سریع با حداکثر کنترل سیستم ایجاد شده است. دیگر نیازی به یادگیری C/C++ برای توسعه برنامه های سیستمی با منابع فشرده و سطح پایین نیست. این کتاب به شما شروعی برای حل برنامه‌نویسی سیستم و وظایف کاربردی با Rust می‌دهد. ما با استدلال در مورد جایگاه منحصر به فرد Rust در چشم انداز امروزی زبان های برنامه نویسی شروع می کنیم. Rust را نصب خواهید کرد و نحوه کار با مدیر بسته آن Cargo را یاد خواهید گرفت. مفاهیم مختلف گام به گام معرفی می شوند: متغیرها، انواع، توابع و ساختارهای کنترلی برای ایجاد زمینه. سپس داده‌های ساختار یافته‌تری مانند رشته‌ها، آرایه‌ها و enums را بررسی می‌کنیم و خواهید دید که تطبیق الگو چگونه کار می‌کند. در تمام این موارد، ما بر روش‌های منحصربفرد استدلالی که کامپایلر Rust برای تولید کد ایمن استفاده می‌کند تاکید می‌کنیم. در ادامه به روش خاص Rust برای مدیریت خطا و اهمیت کلی صفات در کد Rust نگاه می کنیم. با بررسی انواع نشانگرها، ستون ایمنی حافظه به طور عمیق مورد بررسی قرار می گیرد. در مرحله بعد، خواهید دید که چگونه ماکروها می توانند تولید کد را ساده کنند و چگونه پروژه های بزرگتر را با ماژول ها و جعبه ها بسازید. در نهایت، متوجه خواهید شد که چگونه می‌توانیم کد همزمان امن در Rust بنویسیم و با برنامه‌های C رابط داشته باشیم، نمایی از اکوسیستم Rust دریافت کنیم...؛ جلد -- عنوان صفحه -- حق چاپ -- اعتبار -- درباره نویسنده -- درباره منتقد -- www.PacktPub.com -- بازخورد مشتری -- فهرست مطالب -- پیشگفتار -- فصل 1: شروع با Rust -- مزایای Rust -- Trifecta of Rust -- ایمن، سریع و همزمان -- مقایسه با زبان های دیگر -- پایداری Rust و تکامل آن -- موفقیت Rust -- کجا از Rust استفاده کنیم -- Servo -- نصب Rust -- rustc -- کامپایلر Rust -- اولین برنامه ما -- کار می کند با Cargo -- ابزارهای توسعه دهنده -- استفاده از Sublime Text


توضیحاتی درمورد کتاب به خارجی

Leverage the functional programming and concurrency features of Rust and speed up your application development About This Book Get started with Rust to build scalable and high performance applications Enhance your application development skills using the power of Rust Discover the power of Rust when developing concurrent applications for large and scalable software Who This Book Is For The book is for developers looking for a quick entry into using Rust and understanding the core features of the language. Basic programming knowledge is assumed. What You Will Learn Set up your Rust environment to achieve the highest productivity Bridge the performance gap between safe and unsafe languages Use pattern matching to create flexible code Apply generics and traits to develop widely applicable code Organize your code in modules and crates Build macros to extend Rust's capabilities and reach Apply tasks to tackle problems concurrently in a distributed environment In Detail Rust is the new, open source, fast, and safe systems programming language for the 21st century, developed at Mozilla Research, and with a steadily growing community. It was created to solve the dilemma between high-level, slow code with minimal control over the system, and low-level, fast code with maximum system control. It is no longer necessary to learn C/C++ to develop resource intensive and low-level systems applications. This book will give you a head start to solve systems programming and application tasks with Rust. We start off with an argumentation of Rust's unique place in today's landscape of programming languages. You'll install Rust and learn how to work with its package manager Cargo. The various concepts are introduced step by step: variables, types, functions, and control structures to lay the groundwork. Then we explore more structured data such as strings, arrays, and enums, and you'll see how pattern matching works. Throughout all this, we stress the unique ways of reasoning that the Rust compiler uses to produce safe code. Next we look at Rust's specific way of error handling, and the overall importance of traits in Rust code. The pillar of memory safety is treated in depth as we explore the various pointer kinds. Next, you'll see how macros can simplify code generation, and how to compose bigger projects with modules and crates. Finally, you'll discover how we can write safe concurrent code in Rust and interface with C programs, get a view of the Rust ecosystem ...;Cover -- Title Page -- Copyright -- Credits -- About the Author -- About the Reviewer -- www.PacktPub.com -- Customer Feedback -- Table of Contents -- Preface -- Chapter 1: Starting with Rust -- The advantages of Rust -- The trifecta of Rust -- safe, fast, and concurrent -- Comparison with other languages -- The stability of Rust and its evolution -- The success of Rust -- Where to use Rust -- Servo -- Installing Rust -- rustc -- the Rust compiler -- Our first program -- Working with Cargo -- Developer tools -- Using Sublime Text



فهرست مطالب

Preface......Page 20
What this book covers......Page 21
What you need for this book......Page 23
Who this book is for......Page 24
Conventions......Page 25
Customer support......Page 26
Downloading the example code......Page 27
Errata......Page 28
Piracy......Page 29
Questions......Page 30
Starting with Rust......Page 31
The advantages of Rust......Page 32
The trifecta of Rust - safe, fast, and concurrent......Page 34
Comparison with other languages......Page 36
The stability of Rust and its evolution......Page 37
The success of Rust......Page 39
Where to use Rust......Page 41
Servo......Page 42
Installing Rust......Page 43
rustc--the Rust compiler......Page 45
Our first program......Page 46
Working with Cargo......Page 48
Developer tools......Page 52
Using Sublime Text......Page 53
The Standard Library......Page 55
Summary......Page 56
Using Variables and Types......Page 57
Comments......Page 58
Global constants......Page 59
Printing with string interpolation......Page 61
Values and primitive types......Page 63
Consulting Rust documentation......Page 65
Binding variables to values......Page 66
Mutable and immutable variables......Page 68
Scope of a variable and shadowing......Page 70
Type checking and conversions......Page 71
Aliasing......Page 73
Expressions......Page 74
The stack and the heap......Page 76
Summary......Page 80
Using Functions and Control Structures......Page 81
Branching on a condition......Page 82
Looping......Page 84
Functions......Page 86
Documenting a function......Page 90
Attributes......Page 92
Conditional compilation......Page 93
Testing......Page 94
Testing with cargo......Page 97
The tests module......Page 98
Summary......Page 101
Structuring Data and Matching Patterns......Page 102
Strings......Page 103
Arrays, vectors, and slices......Page 108
Vectors......Page 111
Slices......Page 113
Strings and arrays......Page 114
Tuples......Page 116
Structs......Page 118
Enums......Page 121
Result and Option......Page 122
Getting input from the console......Page 123
Matching patterns......Page 126
Program arguments......Page 132
Summary......Page 134
Higher Order Functions and Error-Handling......Page 135
Higher order functions and closures......Page 136
Iterators......Page 139
Consumers and adapters......Page 141
Generic data structures and functions......Page 144
Error-handling......Page 147
Panics......Page 148
Testing for failure......Page 149
Some more examples of error-handling......Page 151
The try! macro and the ? operator......Page 154
Summary......Page 156
Using Traits and OOP in Rust......Page 157
Associated functions on structs......Page 158
Methods on structs......Page 160
Using a constructor pattern......Page 162
Using a builder pattern......Page 164
Methods on tuples and enums......Page 166
Traits......Page 167
Using trait constraints......Page 170
Static and dynamic dispatch......Page 173
Built-in traits and operator overloading......Page 175
OOP in Rust......Page 177
Inheritance with traits......Page 178
Using the visitor pattern......Page 180
Summary......Page 182
Ensuring Memory Safety and Pointers......Page 183
Pointers and references......Page 184
Stack and heap......Page 185
Lifetimes......Page 186
Copying and moving values - The copy trait......Page 190
Let\'s summarize......Page 194
Pointers......Page 195
References......Page 197
Match, struct, and ref......Page 200
Ownership and borrowing......Page 202
Ownership......Page 203
Moving a value......Page 204
Borrowing a value......Page 205
Implementing the Drop trait......Page 208
Moving closure......Page 209
Boxes......Page 211
Reference counting......Page 215
Overview of pointers......Page 217
Summary......Page 219
Organizing Code and Macros......Page 220
Modules and crates......Page 221
Building crates......Page 222
Defining a module......Page 224
Visibility of items......Page 225
Importing modules and file hierarchy......Page 228
Importing external crates......Page 231
Exporting a public interface......Page 233
Adding external crates to a project......Page 234
Working with random numbers......Page 236
Macros......Page 238
Why macros?......Page 239
Developing macros......Page 240
Repetition......Page 242
Creating a new function......Page 243
Some other examples......Page 244
Using macros from crates......Page 247
Some other built-in macros......Page 248
Summary......Page 250
Concurrency - Coding for Multicore Execution......Page 251
Concurrency and threads......Page 252
Creating threads......Page 253
Setting the thread\'s stack size......Page 255
Starting a number of threads......Page 256
Panicking threads......Page 259
Thread safety......Page 260
Shared mutable states......Page 261
The Sync trait......Page 264
Communication through channels......Page 265
Sending and receiving data......Page 266
Making a channel......Page 268
Sending struct values over a channel......Page 269
Sending references over a channel......Page 270
Synchronous and asynchronous......Page 272
Summary......Page 274
Programming at the Boundaries......Page 275
When is code unsafe......Page 276
Using std::mem......Page 278
Raw pointers......Page 279
Interfacing with C......Page 281
Using a C library......Page 283
Inlining assembly code......Page 285
Calling Rust from other languages......Page 287
Summary......Page 288
Exploring the Standard Library......Page 289
Exploring std and the prelude module......Page 290
Collections - using hashmaps and hashsets......Page 291
Working with files......Page 294
Paths......Page 295
Reading a file......Page 297
Error-handling with try!......Page 299
Buffered reading......Page 300
Writing a file......Page 302
Error-handling with try!......Page 304
Filesystem operations......Page 305
Using Rust without the Standard Library......Page 306
Summary......Page 307
The Ecosystem of Crates......Page 308
The ecosystem of crates......Page 309
Working with dates and times......Page 310
File formats and databases......Page 312
Web development......Page 315
Graphics and games......Page 318
OS and embedded system development......Page 320
Other resources for learning Rust......Page 321
Summary......Page 322




نظرات کاربران

تمامی حقوق معنوی و مادی وبسایت متعلق به اینترنشنال لایبرری می باشد
نماد اعتماد الکترونیکی