1. Core Syntax

The structure of Swift Структура Swift

- Прежде чем мы перейти в Xcode давайте взглянем на некоторые основные SWIFT-код. Не волнуйтесь о точном синтаксисе прямо сейчас, я просто хочу указать на несколько вещей об общем внешний вид и структуру Свифт. Теперь, если это было первое Swift код никогда не видел, как программист вы могли бы еще сделать несколько предположений по этому поводу в течение нескольких секунд. Это сначала кажется, чтобы быть C под влиянием языка. Под этим я подразумеваю, что мы используем фигурные скобки, чтобы окружить блоки кода, существует ключевые слова в нижнем регистре, как если бы, еще, и возвращение. Это, если заявление не должно быть довольно легко читается, независимо от языка программирования вы привыкли.

Так что, да, Swift абсолютно C влиянием lanague. Мы используем фигурные скобки, есть много ключевых слов вы узнали работает в любой другой C под влиянием языка, хотя, как мы увидим, есть также ключевые слова вы ожидаете найти в объектно-ориентированном языке, как класса, частной и общественности. Но есть ключевые слова, вы не можете быть знакомы с, пожалуй, как FUNC здесь, хотя вы могли бы сделать хорошую догадку на это есть и другие ключевые слова, которые являются специфическими для Swift. И мы, конечно, пройти через все из них, но в то время как Свифт С-влияние это не скованы или наручниками к С.

В отличие от языка Objective-C, Swift не пытается быть C совместимы. Как Objective-C разработчики будут знать, вы можете взять участок старой школы C кода из 1970 с чем-то и вставьте его прямо в Objective-C программы. Теперь вы попробовать, что у Свифта и все, что вы получаете экран, полный ошибок компиляции. Swift является его собственный язык, это не расширенный чего-то другого. Так что и другие сходства у нас есть? Ну мы отступ наш код в Swift, как вы можете видеть, но отступ только для чтения. В отличие от сказать Python, отступы у Свифта не имеет смысла в себе, хотя есть некоторые вещи, которые я укажу к пробелам в ближайшее время.

Теперь комментарии, как вы могли бы ожидать в С-влиянием языка. Это просто // начать однострочный комментарий и многострочные комментарии будут начинаться с / * и заканчиваются * /, но в то время как есть много общего Swift также немедленно дает нам некоторые ключевые отличия от большинства C-повлиявших языках. Во-первых, Swift отчетность не нужно Точка с запятой в конце. Обратите внимание, как я говорю это, вам не нужно запятой. Вы можете иметь их, он не будет вызывать ошибку, если вы поставите точку с запятой в конце оператора.

И есть два причина, почему вы можете иметь их. Во-первых, если вы хотите написать несколько операторов в одной строке, вы должны разделить их точкой с запятой. Это не очень полезно причина, но вы можете сделать это. Во-вторых, скорее всего, причина просто, что вы, как и я, имеют привычку лет, набрав запятой в конце вашего заявления, так что если вы бессознательно написать тот, который вы не хотите, чтобы это вызвать ошибку компиляции каждый раз. Так что они позволили, они не нужны. Боковая панель, если вы программируете наличие вы будете знать, что это язык, где вы можете опустить большинство запятой, но даже если вы можете большинство программистов Сделайте это привычкой в любом случае, чтобы написать их.

Это то, что руководящие принципы стиль будет рекомендовать для различных причин, включая некоторые досадные ошибки, так что знаю, что у Свифта это не относится.Стандартная практика это вам не написать запятой. Собственный пример кода от Apple не использует их, конечный боковой панели.Следующее отличие в том, что в отличие от многих языков C-стиле нам не нужно основной метод или основную функцию, чтобы сказать, где начинается основной Swift программа. Если бы я просто написал несколько Свифт, как это и побежал, было бы начать с самого верха и работать свой путь вниз. И, конечно, как мы получим в более сложных приложений, разбросанных по нескольким файлам кода мы хотим, чтобы контролировать точку входа, и мы, безусловно, может сделать это, но мы не нужен основным методом простого SWIFT-код.

И это приводит нас к следующему вопросу, а как мы пишем и запустить простой Swift программу? До следующего.

Writing Swift in playgrounds

- As a programmer, not just in the Apple world, but in Windows or Linux development too. If you have an idea and you just want to write a few lines of code, well you often can't. You can't write a few lines of code. You have to create some structure for it first. That often means creating a new project in your IDE whether that's Xcode or something like a clip or visual studio. Another, create a folder somewhere, perhaps with some configuration files and spawn up some default classes and boilerplate code. Maybe a user interface. All just to allow you to finally write your few lines.

Most developers end up with dozens of tests something, something projects all over their systems. Okay, not a huge blow back but another speed bump. With Swift, we don't need to do that. We can use something called playgrounds. Playground is a new feature in Xcode six introduced for the Swift language. There are new document type. A Swift playground is a self-contained single file, not a project. That's kind of the point. It lets you quickly write some code and test that code without all the overhead and wait what becomes with the project.

But it's not just about having a quick way to write code. What's unusual and different about playgrounds is it continuously show you the results of your Swift as you are writing and changing it. They automatically execute and refresh all the time. They're great way to experiment with Swift and to learn it. In this course, we'll use playgrounds rather than creating entire projects in Xcode. When you open Xcode six, the first option on the welcome screen is to get started with the playground. Although you can use this option, you can also create a playground from the regular file menu in Xcode.

Either way that you choose to do this, I'm going to ask you if you want this playground targeted at iOS or OS X development. All this is going to do is link to the typical frameworks you'd need if you're writing either iOS or Mac applications. Now for us in this course, it doesn't matter at all. We're focusing on the Swift language itself, not on user interface stuff. So I could choose either. I'll just leave it at iOS and click next. Then we'll just save this somewhere, anywhere. It doesn't matter. There's no magic location for playgrounds. I'll save mine to the desktop.

The font is a little small so I'm going to make one quick change to Xcode. You don't need to do this but I just want to increase the size of it so it makes it easier recording this course. A new playground by default appears with two sections. A code editor section on the left and the results pane on the right. You can drag the bar in the middle to rearrange the proportion of this. There is a third section to playgrounds called the timeline which we'll see in a moment. But what you won't see when a playground opens is the usual project settings, project editor, configuration options, toolbar, etc, etc, etc, that you would usually get in a typical programming IDE because, although Xcode can certainly do all that, again, this is simple.

This isn't part of a project. This isn't a part of anything. It's just a standalone Swift playground file. We write our Swift code and it's a little here provided by default. As we write it, we'll immediate see the impact of that code appear in the results pane on the right hand side. That's without explicitly running it or compiling it. So I'm going to leave the default code here and just create a simple variable. Var highscore equals 100. It's going to show me immediately the result of this expression is that high score is 100.

I then decide to add something to this. Add 50. It's going to recalculate that. I'm not hitting any keys here. It just shows me that it's 150. As I'm typing, you'll see the text in the results pane will flicker between grey and black. That's because as we add and change code, and if I change this, say to 99, it's going to update and recalculate and reevaluate itself to make sure the results are all still correct. So when the results are grey, what's happening is the playground is recalculating. When it's finished recalculating, the results are shown in black text.

If you make it change and the results on the right hand side are still in grey, then there's something wrong with your code and the playground can't figure it out. Now not all code you write will show you individual single values on the right hand side. Let's say I add a simple loop. Again, don't worry about the exact syntax yet. We'll get to that. This loop is going to iterate a hundred times, incrementing an index called i and adding the current value of that to our high score variable. So the results pane just shows me here that this happens 100 times.

Well, this is pretty good. At a glance, I can tell if I got an off-by-one or a fencepost error but it's not showing me the actual value of this high score variable and how that is being changed inside the loop. But if I mouse over this line in the results pane section, I'll see two icons appear. This one's called the quick look icon, the eyeball. We'll get into this later. There's also a circle with a crosshair called the value history button. If I click the value history button, I will see the third section of the playground appear called the timeline.

We just rearrange this a little bit so it's easier to read. The timeline is going to generate a chart which shows the changes over time that come from this statement. The addition to the high score variable inside the loop. Well not only this but there's a slider at the bottom of the window and I can drag this to simulate going back and forth through the iteration of this loop and seem how the value changes for everyone. This can be extremely useful when you're diagnosing loops that aren't doing what you'd think they should be doing. Now having said that, I don't always need the timeline.

If I simply wanted to know the final value of this high score variable after the loop has finished executing, I can easily get to that too. I'll close the timeline down. Just go back to the regular view here. Now to write a line of a Swift to spit out the value of a variable, you might expect that we need some kind of print statement or a console statement or log statement. But in a playground, we don't even need that. The simplest way to see the value of a variable here is just to write the name of this variable on its own line.

I'll just write high score. Because as far as the playground is concerned, this is just a very simple expression and it's going to evaluate that expression and you'll see the results over here in the right hand side. The current value of high score. So notice, we're not just seeing the final result. We are seeing the values change over time without writing any logging statements, without even explicitly executing this code, and, as a playground, is constantly updated. I can make a simple change. They, back up at the top. Change this one to 999 and it will immediately trickle down and show the resulting effects on the rest of the code.

So they're a fantastic interactive way to learn Swift. Even after you're comfortable with it, they're great way to experiment and develop ideas. You can always take code that you've written in a playground and put it into a more formal project later if it's useful. All right, there is more to playgrounds but this is certainly enough to get us moving forward into the core syntax of Swift.

Writing Swift in playgrounds Написание Свифт на игровых площадках

- Как программист, а не только в мире Apple, но в окнах или разработки Linux тоже. Если у вас есть идея, и вы просто хотите, чтобы написать несколько строк кода, а вы часто не можете. Вы не можете написать несколько строк кода. Вы должны создать структуру для него в первую очередь. Это часто означает создание нового проекта в вашей IDE, что будь Xcode или что-то вроде клипа или Visual Studio. Другой, создайте папку куда-нибудь, возможно, с некоторыми файлами конфигурации и порождают некоторые классы по умолчанию и стандартного кода. Может быть, пользовательский интерфейс. Все просто, чтобы позволить вам, наконец, написать свои несколько строк.

Большинство разработчиков в конечном итоге с десятками тестов что-то, что-то проектов на всем протяжении их систем. Хорошо, не огромный удар назад, но другой лежачего полицейского. С Свифт, нам не нужно этого делать. Мы можем использовать то, что называется площадки. Детская площадка новая функция в Xcode шесть введен для Swift языке. Есть новый тип документа.Swift площадка автономный один файл, а не проект. Это вид точки. Это позволяет быстро написать код и проверить, что код без всех накладных расходов и ждать, что будет с проектом.

Но это не просто о том, быстрый способ написания кода. Что необычного и другое о детских площадок это постоянно показывают вам результаты вашего быстро, как вы пишете, и изменить его. Они автоматически выполнять и обновить все время. Они отличный способ поэкспериментировать с быстрой и учиться. В этом, конечно, мы будем использовать игровые площадки, а не создавать целые проекты в Xcode. Когда вы открываете Xcode шесть, первый вариант на экране приветствия, чтобы начать работу с детской площадкой. Хотя вы можете использовать эту опцию, вы также можете создать площадку от обычного меню файла в Xcode.

В любом случае, что вы решите это сделать, я собираюсь спросить вас, если вы хотите, чтобы эта площадка, нацеленные на развитие IOS или OS X. Все это будет сделать, это ссылка на типичных структур вам нужно, если вы пишете либо IOS или приложений Mac. Теперь для нас в этом, конечно, это не имеет значения. Мы уделяем особое внимание на самом языке Swift, а не на пользовательском интерфейсе вещи. Так что я мог выбрать либо. Я просто оставить его на прошивкой и нажмите кнопку Далее. Тогда мы просто сохранить это где-то, в любом месте. Это не имеет значения. Там нет никакой магии место для детских площадок. Я спасу мои на рабочий стол.

Шрифт очень маленький, так что я собираюсь сделать один быстрый изменения в Xcode. Вам не нужно, чтобы это сделать, но я просто хочу, чтобы увеличить размер этого так, это облегчает запись этот курс.Новая детская площадка по умолчанию появляется с двумя секциями.Раздел Редактор кода слева и панель результатов справа. Вы можете перетащить панель в середине, чтобы изменить пропорцию этого. Существует третий раздел для игровых площадок называется график, который мы увидим в данный момент. Но то, что вы не будете видеть, когда открывается площадка обычные настройки проекта, проекта, редактор, параметры конфигурации, панель инструментов, и т.д., и т.д., и т.д., что вы обычно получаете в типичном программирования IDE, потому что, хотя Xcode, безусловно, может делать все, что , опять же, это просто.

Это не является частью проекта. Это не является частью чего-либо. Это просто автономный Swift файл площадка. Мы пишем наш код Swift, и это немного здесь предоставляется по умолчанию. Как мы пишем это, мы будем непосредственным см последствия этого кода отображаются в панели результатов в правой стороне. Это без явного работает это или компиляции. Так что я ухожу код по умолчанию здесь и просто создать простой переменной. Var рекорд равен 100. Это собирается показать мне сразу результат этого выражения в том, что высокая оценка 100.

Я тогда решили добавить что-то к этому. Добавить 50. Это будет пересчитать это. Я не задев никаких ключей здесь. Это просто показывает мне, что это 150. Как я печатаю, то вы увидите текст в панели результатов будет мерцать между серым и черным. Это потому, что, как мы добавлять и изменять код, и если я изменить это, скажем, до 99, это будет обновлять и пересчитывать и пересматривать себя, чтобы убедиться, результаты все еще правильна. Так, когда результаты серые, что происходит, детская площадка пересчете. Когда закончено пересчете, результаты показаны черным цветом.

Если вы сделаете это изменить, и результаты на правой стороне по-прежнему серым цветом, то есть что-то не так с вашим кодом и детская площадка не могу понять его. Теперь не весь код вы пишете покажет Вам индивидуальные единичные значения на правой стороне. Скажем, я могу добавить простой цикл. Опять же, не беспокоиться о точном синтаксисе еще. Мы вернемся к этому. Этот цикл будет повторять сто раз, увеличивая индекс звонил, я и добавления текущее значение, что к нашей большой переменной баллов. Таким образом, результаты панели просто показывает мне здесь, что это происходит в 100 раз.

Ну, это очень хорошо. На первый взгляд, я могу сказать, если я получил офф за одним или ошибку fencepost но это не показали мне значение этой высокой переменной баллов, и как это в настоящее время изменилась внутри цикла. Но если я мыши на эту линию в разделе панели результатов, я буду видеть появляются две иконы. Это один называется значок быстрый взгляд, глазное яблоко. Мы войдем в это позже. Там также круг с перекрестием называемой кнопку история значений. Если я нажимаю на кнопку История значение, я буду видеть Третья часть детской площадке появляются назвал сроки.

Мы просто переставить этот немного, так что легче читать.График будет создать диаграмму, которая показывает изменения с течением времени, которые приходят от этого заявления. Добавление к высокой переменной нот внутри цикла. Ну не только это, но есть слайдер в нижней части окна, и я могу перетащить это для имитации ходит взад и вперед по итерации этого цикла и, кажется, как изменяется значение для всех. Это может быть очень полезно, когда вы диагностики петли, которые не делают то, что вы думаете, что они должны делать. Теперь, говорит, что я не всегда нужно на временной шкале.

Если бы я просто хотел бы знать, окончательное значение этой высокой переменной забить после петля закончил работу, я могу легко добраться до этого тоже. Я закрою сроки вниз. Просто вернитесь к обычному виду здесь. Теперь, чтобы записать строку в Swift выплюнуть значение переменной, можно ожидать, что мы должны какую-то печать заявлении или консоли заявление или войти заявление. Но в детской площадкой, мы даже не нужно.Простейший способ увидеть значение переменной здесь просто написать имя этой переменной на ее собственной линии.

Я просто напишу высокий балл. Потому что, насколько площадка, то, что это просто очень простое выражение, и это будет оценить это выражение, и вы увидите результаты здесь, в правой стороне.Текущее значение высокий балл. Так заметить, что мы не просто видеть конечный результат. Мы видим, что значения изменяются с течением времени без написания каких-либо рубок заявления, даже не явно выполнения этого кода, и, как детская площадка, постоянно обновляется. Я могу сделать простое изменение. Они, резервное копирование на самом верху. Изменение этого от одного до 999, и он будет сразу же стекает и показать в результате воздействия на остальной части кода.

Таким образом, они фантастические интерактивный способ узнать Свифт. Даже после того как вы комфортно с ним, они отличный способ экспериментировать и развивать идеи. Вы всегда можете взять код, который вы, написанный на детской площадке и поставить его в более формальную проекта позже, если это полезно. Ладно, это еще не площадок, но это, конечно, достаточно, чтобы заставить нас двигаться вперед в основной синтаксис Свифт.

Declaring variables

- The first thing we're likely to do in any programming language is make a variable. So let's start there. In Xcode, I'll make a new playground. I'll call this Variables and save it on my desktop. There's an example in the default code that, in Swift, we use the keyword var to declare a variable. It's the word var, all lower case, and then our variable name. The suggested naming convention, as in many languages, is that variable names are camel case, using a lower-case first letter. But I am not finished. I'm going to give this variable an initial value.

So I'll set it equal to 100. Many programmers at this point start wondering, "So is this an integer variable? "Specifically, can we change this to hold "a floating point value? "Could it then hold a string or a Boolean or an object? "Does any of this matter?" All good questions. We will deal with them momentarily. First, a quick but necessary sidebar. You see, var is a keyword that we have in other languages. It's in JavaScript. Var is in PHP, it's in Csharp, it's in Go. And because of that, var has a little bit of baggage that some programmers might be bringing to the table because, in other languages, this keyword var can be one of multiple options for creating a variable.

Sometimes you use var and sometimes you don't. So let me be clear here: when we make a variable in Swift, we use the keyword var to do it. It is not one of the options for declaring a variable, it is the only way we declare a variable. Every variable in Swift is declared with the keyword var. (with rising volume) Let me say that again. Every variable in Swift is declared with the keyword var. End sidebar. So we move on, and I'll declare two more variables, also giving them initial values.

As you can see from this, string values are surrounded by double quotes, and those of you coming from Objective-C will be glad to see that we no longer need the leading @ sign in front of a string. We also have Boolean, which can be true or false. Again, for those of you coming from Objective-C, that's true or false, as opposed to yes or no. Now, if the first Swift you ever saw was just these few lines of code, all using the word var, but with different types of values, you would be forgiven for thinking that, perhaps, Swift is an un-typed, or at least a loosely-typed language, that it doesn't seem to matter what kind of value a variable holds.

Maybe it's a string; maybe it's an integer; maybe it's a Boolean. Well, I would forgive you for initially thinking that, but you would be barking up the wrong tree because Swift is a type-save language. It is strongly typed. All variables in Swift are of a specific data type. The variables are integers or they are string variables or Boolean variables or arrays or some custom object, but they are something specific. They are something in particular. So what's happening here is that, when you write simple code like this, Swift will do what's called type inference.

It infers the type of the variable from the code that we've written. The compiler looks at this code and says, "Well, this is quite obviously an integer variable, "and this one is quite obviously a string variable, and this one is quite obviously a Boolean variable." We don't have to tell Swift this explicitly because it's completely obvious from these initial values that we've provided. So all variables in Swift are of a specific type. And unlike, say, JavaScript, you cannot change the type of a variable after it's been defined.

So if I've declared some variables and Swift has inferred their type, that firstName is a string, and then, later, I add another line of code like this, I would expect to see an error because I'm now trying to treat firstName as an integer. And we've got this exclamation mark appearing on the left-hand side, and also, all the text is showing up in gray in our results pane, which is a hint that Swift cannot evaluate this playground properly. If I click that, we see the error message. It's not the friendliest one in the world: "Type 'String' does not conform to protocol "'IntegerLiteralConvertible'," basically saying, you can't take firstName, which is a string, and treat it like it's an integer.

It is not going to implicitly convert an integer value into a string value. It won't do that. Now, there are all sorts of options for explicitly converting values from one type to another, but it won't just happen automatically. That's a safety feature of Swift. It's not going to implicitly change one thing into another kind of thing. "But," you might be wondering, "what if I don't, or can't, "provide an initial value for Swift to infer? "What if I want to declare a variable and then, later, "set its value?" Well, that's fine, you can do that.

What happens is, if you write a line of code like this, var myVariable, and there's no initial value, then Swift cannot infer a type because there is nothing to infer. That's okay, but it means that this code, by itself, is not enough. And if I try and leave this alone, I'll see that I've got the exclamation mark showing up over here. It would also give me a compile error if I was writing this in a proper project in Xcode. And the error would be that "Type annotation is missing." Swift is saying, "I don't know what this variable "is supposed to be," because, when we declare variables in Swift, either we provide an initial value so that Swift can easily infer the type, or, if we don't do that, then we must say explicitly what the type of this variable is.

And we do this by writing a colon after the variable name and then the data type we want for that variable. So I'm going to ahead and make this an Int. This is now showing up. There's no exclamation mark on the left and all the text is showing up in black. So it seems that Swift understands this code just fine. So this is called the type annotation, the colon and then the data type. Think of the colon as meaning 'is of type,' so myVariable is of type Int, and Int being the classic Swift integer data type.

Now, this point is where some tutorials would go through a big list of all possible data types and their sizes and ranges. I'm not going to do that here. We'll talk about some of these in more detail later. But I'll leave some of the specifics as an exercise for you. For now, know that straightforward data types include Int, for integer, Float and Double, for 32 and 64-bit floating point types. We have a very powerful string type. There's also a single-character type, and there's the Bool with, again, true or false.

And notice that all the types here, which are showing up in purple -- they're color-coded in Xcode -- they begin with an uppercase first letter, even the simple ones like Int. Now, there are, of course, more complex data types we can use. There are collections, like arrays and dictionaries, or custom objects. We will see these all later. Now, if you want to be explicit about the data type, and also provide an initial value, I could certainly go ahead and do that. Say you're creating a variable called lastName, saying it's a string and giving it a value, or saying it's a Boolean or an integer and giving those specific values, as well.

I'm getting a complaint here about this variable, just because it already exists here. Cannot put the (mumbling). I've declared it twice. That's not going to work very well. We'll change that and then let it go ahead and update. This is perfectly acceptable code. So, var lastName, the type annotation, and then the initial value. But if a value is so obviously a string or so obviously a Boolean or so obviously an integer, there is simply no need for the type annotation. These are optional pieces.

You can remove them if you want to. So let me clear up a misconception. The point of type inference in Swift is not to try and obscure or hide the data types from us as programmers. It's quite the opposite. It assumes that, when we write code like this, we deeply understand what our data types are. Type inference is simply there to make code more concise and more readable. So if the data type is blindingly obvious, both to us and to the compiler, then we just let Swift infer it. But if it's not obvious, particularly when we're not providing a default value, as with this interestRate variable down here, then we need to provide that type annotation.

We need to say what the type is. And you will see this kind of thing a lot, that many decisions in the Swift language are to improve the clarity and the readability, but also the safety, of our code.

Declaring variables Объявление переменных

- Первое, что мы, вероятно, сделать на любом языке программирования, это сделать переменную. Итак, давайте начнем там. В Xcode, я сделаю новую спортивную площадку. Я позвоню эти переменные и сохранить его на моем рабочем столе. Там это пример кода по умолчанию, что у Свифта, мы используем Вар ключевое слово, чтобы объявить переменную. Это слово Var, все в нижнем регистре, а затем наш имя переменной.Предложил именования, как и во многих языках, в том, что имена переменных Camel Case, используя нижний регистр первую букву. Но я еще не закончил. Я собираюсь дать этой переменной начальное значение.

Так что я установить его равным 100. Многие программисты на данный момент начинают интересоваться, "Так это целая переменная?" В частности, мы можем изменить это, чтобы держать "значение с плавающей запятой?" Может затем, удерживая строку или Логическое или объект? "Кто-нибудь из этого вопроса?" Все хорошие вопросы. Мы будем иметь дело с ними на мгновение. Во-первых, быстро, но необходимо боковая панель. Вы видите, ВДП ключевое слово, которое мы имеем на других языках. Это в JavaScript. Var в PHP, это в CSharp, это в Go. И из-за этого, вар имеет немного багажа, что некоторые программисты могут приносить к столу, потому что в других языках, эта переменная ключевое слово может быть одним из нескольких вариантов для создания переменной.

Иногда вы используете VAR, а иногда и не нужно. Итак, позвольте мне быть ясным здесь: когда мы делаем переменную в Swift, мы используем Вар ключевое слово, чтобы сделать это. Это не один из вариантов для объявления переменной, это единственный способ объявить переменную. Каждая переменная в Swift объявлен с переменной по ключевым словам. (при повышении объема) Позвольте мне сказать, что снова. Каждая переменная в Swift объявлен с переменной по ключевым словам. Конец боковой панели. Таким образом, мы двигаться дальше, и я объявлю еще две переменные, а также дает им начальные значения.

Как вы можете видеть из этого, значения строк в двойных кавычках, и тех, кто планирует с Objective-C будет рад не видеть, что мы больше не нуждаемся ведущую знак @ в начале строки. У нас также есть логический, которые могут быть истинными или ложными. Опять же, для тех из вас, исходя из Objective-C, правда это или ложь, в отличие от да или нет. Теперь, если первый Swift Вы когда-нибудь видели, было всего эти несколько строк кода, все с помощью слов VAR, но с разными типами значений, вы бы подумать, что, может быть, Свифт нетипированные, или, по крайней мере,свободно типизированный язык, что, кажется, не имеет значения, какой вид значения имеет переменную.

Может быть, это строка; может быть, это целое; может быть, это Boolean. Ну, я бы простить вас за первоначально думал, но вы бы лаять на ложный след, потому что Свифт типа сохранить язык. Это сильно типизированных. Все переменные в Swift имеют определенного типа данных. Переменные являются целыми числами, или они являются строковыми переменными или логические переменные или массивы или некоторые пользовательский объект, но они что-то конкретное. Они что-то в частности. Так, что здесь происходит, что когда вы пишете простой код, как это, Свифт будет делать то, что называется вывод типа.

Это выводит тип переменной из кода, который мы написали.Компилятор смотрит на этот код и говорит: "Ну, это совершенно очевидно, целая переменная," и это одно совершенно очевидно строковая переменная, и это одно совершенно очевидно логическая переменная. "Мы не должны сказать Свифт это явно, потому что это совершенно очевидно, от этих начальных значений, которые мы предоставили. Таким образом, все переменные в Swift имеют определенного типа. И в отличие от, скажем, JavaScript, вы не можете изменить тип переменной после того как она определена.

Так что, если я объявил некоторые переменные и Свифт вывод их тип, что Имя это строка, а затем, позже, я добавляю еще одну линию кода, как это, я бы ожидать, чтобы увидеть ошибку, потому что я сейчас пытаюсь лечить Имя виде целого числа. И у нас есть этот восклицательный знак, появляющийся на левой стороне, а также, весь текст появляется в сером в нашем панели результатов, что является намеком, что Свифт не может оценить эту площадку надлежащим образом. Если я нажимаю, что мы видим сообщение об ошибке. Это не дружелюбных в мире: "Тип 'Строка' не соответствует протоколу" "IntegerLiteralConvertible", "в основном говорят, вы не можете взять Имя, которое строка, и относиться к нему, как будто это целое число.

Это не собирается неявно преобразовать целое значение в строковое значение. Он не будет делать этого. Сейчас есть всевозможные варианты для явного преобразования значения из одного типа в другой, но это будет не просто происходит автоматически. Это функция безопасности Свифта. Это не собирается неявно изменить одну вещь в другую рода вещи. "Но", вы можете быть удивлены, "Что делать, если я не делаю, или не может," обеспечить начальное значение для Swift сделать вывод? "Что делать, если я хочу, чтобы объявить переменную, а затем, позже," установить его значение? "Ну, это нормально, вы можете сделать это.

Что происходит, если вы написать строку кода, как это, торговцы MYVARIABLE, и нет никакого начального значения, то Свифт не можем вывести тип, потому что нет ничего, чтобы сделать вывод. Это хорошо, но это означает, что этот код, сам по себе, не достаточно. И если я попытаюсь оставить это в покое, я буду видеть, что у меня есть восклицательный знак, показывающий до сюда. Это также даст мне ошибку компиляции, если я пишу это в надлежащем проекта в Xcode. И ошибка будет то, что "тип аннотации отсутствует." Свифт сказал: "Я не знаю, что эта переменная" должна быть ", потому что, когда мы объявляем переменные в Swift, либо мы предоставляем начальное значение, так что Swift может легко определить тип, или, если мы не 'т сделать это, то мы должны явно сказать, что тип этой переменной.

И мы делаем это, написав двоеточие после имени переменной, а затем тип данных мы хотим для этой переменной. Так что я собираюсь вперед и делают это Int. Это теперь появляется. Там нет восклицательный знак на левой и весь текст появляется в черном цвете. Так что, похоже, что Свифт понимает этот код просто отлично. Итак, это называется тип аннотации, толстой кишки, а затем тип данных. Подумайте толстой кишки в том смысле, "имеет тип", так MYVARIABLE имеет тип Int, и Int будучи классическим Swift целочисленный тип данных.

Теперь эта точка, где некоторые учебники будут проходить через большой список всех возможных типов данных и их размеров и диапазонов. Я не собираюсь делать это здесь. Мы поговорим о некоторых из них более подробно. Но я оставлю некоторые особенности в качестве упражнения для вас. В настоящее время, известно, что простые типы данных включают Int, что для целого, с плавающей точкой и двойные, для 32 и 64-битных типов с плавающей точкой. У нас есть очень мощный тип строки. Там также тип односимвольный, и есть Bool с, опять же, истинными или ложными.

И обратите внимание, что все типы здесь, которые показаны в фиолетовый - они цветом в Xcode - они начинаются с заглавной первую букву, даже простых, как Int. Теперь, есть, конечно, более сложные типы данных мы можем использовать. Есть коллекции, как массивы и словари, или пользовательских объектов. Мы увидим это позже всех. Теперь, если вы хотите быть четко о типе данных, а также обеспечить начальное значение, я мог бы, конечно, идти вперед и делать это. Скажем, вы создаете переменную Фамилия, говоря, что это строка и придания ей значения или сказать, что это логическое ИЛИ число и дает те конкретные значения, а также.

Я получаю жалобы здесь об этой переменной можно, только потому, что он уже существует здесь. Не можете положить (бормотание). Я объявил его дважды. Это не будет работать очень хорошо. Мы изменим это, а затем отпустить ее вперед и обновить. Это вполне приемлемо код. Так, вар Фамилия, тип аннотации, а затем начальное значение. Но если значение так очевидно строка или так, очевидно, Boolean или так, очевидно, число, есть просто нет необходимости в аннотации типа. Они не являются обязательными штук.

Вы можете удалить их, если хотите. Итак, позвольте мне прояснить заблуждение.Точка типа вывода в Swift не попробовать и скрывать или скрывать типы данных от нас, как программистов. Это совсем наоборот. Оно подразумевает, что когда мы пишем код, как это написать, мы глубоко понимаем, что наши типы данных. Тип вывода просто там, чтобы сделать код более кратким и более читаемым. Так что, если тип данных стало очевидным, как для нас, и для компилятора, то мы просто дайте Swift умозаключениях. Но если это не очевидно, особенно, когда мы не обеспечивая значение по умолчанию, как с помощью этой переменной InterestRate сюда, то мы должны обеспечить этот тип аннотации.

Надо сказать, что тип. И вы увидите, что такого рода вещи много, что многие решения в Swift языка для повышения четкости и читаемости, но и безопасность, нашего кода.

Creating constants

- So, we just started using the Var keyword. I have a new playground here but here's where I try and persuade you to use a different keyword. That in Swift, we favor using the keyword Let, instead of Var when creating pieces of named data. Now hang on a second, Simon, you might think. Didn't you just say that Swift uses Var to declare every variable. Well, yes I did, and that's absolutely true. Var declares a variable and using the keyword Let we create a constant instead. It is still a piece of named data, but once it's been given a value, that value can't change, it can't vary, it is not a variable.

If I try and change it to something else, I would expect a compile error. This value needs to stay constant through the lifetime of the executing program. Other than being unable to change it, everything else about the syntax of using Var, and Let is identical. You can use one keyword or the other. Like all variables, all constants have a name, they have a specific data type. They have a value. If Swift can infer the type from the initial value, it will.

If it can't or if you prefer to be explicit, we need that type (annotationly) colon space type name after the name of the constant. It is most common to declare a constant and also set its value on the same line, and when you're using a playground, you always need to provide the value of a constant immediately. Later, when creating our own classes, it's possible to declare the constant in one location and later set its value. Perhaps, loading a value from elsewhere, external data like a file or a webservice or user input, but you can still only do it once.

Unlike a variable, once you have assigned a value to a constant you can't then change that value, any attempt to do so will cause an error. Here's the thing, some programmers might be zoning out of it, because there's nothing remarkable about constants. We can create them in most languages. There's often a keyword like const, or final, or read only we use to declare one. Constants are one of those things that a lot of programmers don't do very much. The culture that evolves around some languages means, yeah, you might be able to do them, but you just don't see them that much. You don't really think about them.

So know that in Swift, the use of constants is encouraged. They are regarded as important, and they are common placed. There is all ready a stated best practice to use Let wherever possible. First, it's a safety feature. Whatever you can lock down, whatever constraint you can put in place around you code, do it. Also, if we know that we have a bunch of values that won't change during the lifetime of the program, there are even some performance optimizations the compiler can do. Now, of course, there's nothing wrong with Var. When you have a piece of data that needs to change through the life of the program, use Var and go in all good health.

You will see a lot of constants used in Swift. If you're not in the habit of making them, make an effort to use Let for a while. It might surprise you how often your pieces of data don't need to change once they've been given a value. Now, if you've worked in Objective-C, I want to make one explicit comparison here, that might add some clarity to this. It's a common design patent in Objective-C to find two versions of a class, an Immutable or fixed version, and a Mutable or changeable one. So, we have the NS String which is fixed, and we have the NS Mutable String which is changeable.

We have the NS Array. We have the NS Mutable Array and so on. Well in Swift, we don't worry about having different versions of classes. Simply put, if you declare a String using Var, you have a Mutable String, because it's variable so you can change it. If you create a String using Let, then you have an Immutable String, it's a constant and you can't change it. As we'll see, this idea works with more complex objects like collections too. We are getting a little bit ahead of ourselves. We haven't gotten into objects yet. So, we will revisit and refine this idea later on.

Just know that the recommendation for using Let to create constants in Swift is not just for primitive simple kinds of values, it's for everything.

Creating constants Создание константы

- Итак, мы только начали, используя ключевое слово Var. У меня есть новая детская площадка здесь, но вот где я пытаюсь убедить вас использовать другое ключевое слово. Это у Свифта, мы выступаем за помощью ключевого слова Пусть вместо Var при создании части названных данных. Теперь подожди секунду, Симон, вы могли бы подумать. Разве вы не просто сказать, что Свифт использует Var объявить каждую переменную. Ну, да, я сделал, и это абсолютно верно. Var объявляет переменную и с помощью ключевого слова Давайте мы создаем постоянное вместо этого. До сих пор часть названных данных, но как только он был дан значение, это значение не может изменить, она не может меняться, это не является переменной.

Если я пытаюсь и изменить его на что-то другое, я бы ожидать ошибку компиляции. Это значение должно оставаться постоянным в течение всего срока службы выполняемой программы. Кроме того, что не в состоянии изменить его, все остальное о синтаксисе и использовании Var, и пусть идентичны. Вы можете использовать одно ключевое слово или друга. Как и все переменные, все константы есть имя, у них есть определенный тип данных. Они имеют значение. Если Swift может определить тип из первоначальной стоимости, так и будет.

Если он не может, или если вы предпочитаете, чтобы быть явным, мы должны этому типу (annotationly) толстой кишки пространство имя типа после имени константы. Она является наиболее распространенным объявить константу, а также установить его значение на той же линии, и когда вы используете площадку, вы всегда должны незамедлительно предоставить значение постоянной. Позже, при создании собственных классов, это можно объявить константу в одном месте, а затем установите его значение. Может быть, загружаются значения из других источников, внешних данных, таких как файл или веб-сервиса или пользовательский ввод, но вы все равно можете сделать это только один раз.

В отличие от переменных, как только вы назначили значение постоянной вы не можете затем изменить это значение, любая попытка сделать это приведет к ошибке. Вот вещь, некоторые программисты могут быть зонирование из него, потому что нет ничего примечательного констант. Мы можем создать их в большинстве языков. Там часто ключевое слово как сопзЬ или окончательным, или только для чтения мы используем, чтобы объявить один. Константы одна из тех вещей, что многие программисты не делают очень много.Культура, которая развивается вокруг некоторых языках означает, да, вы могли бы быть в состоянии сделать их, но вы просто не видите их так много. Вы действительно не думать о них.

Так знайте, что у Свифта, использование констант приветствуется. Они рассматриваются как важный, и они являются общими размещены. Существует все готово заявил рекомендуется использовать Пусть там, где это возможно. Во-первых, это функция безопасности. Что бы вы можете заблокировать, независимо от ограничений вы можете положить в место вокруг вас код, сделайте это. Кроме того, если мы знаем, что у нас есть куча значений, которые не меняются в течение всего срока службы программы, есть даже некоторые оптимизации производительности компилятор может сделать. Сейчас, конечно, нет ничего плохого в Var. Если у вас есть кусок данных, которые необходимо изменить в течение всего срока реализации программы, используйте Var и идут во всех хорошим здоровьем.

Вы увидите много констант, используемых в Свифт. Если вы не в привычку делать их, сделать усилие, чтобы использовать Пусть на некоторое время. Возможно, вас удивит, как часто ваши части данных не нужно менять, как только они дали значение. Теперь, если вы работали в Objective-C, я хочу, чтобы один явный сравнение здесь, что бы добавить некоторую ясность в этот. Это общий патент на промышленный образец в Objective-C, чтобы найти две версии класса, непреложный или стационарном исполнении, и Мутабельном или изменяемой один. Таким образом, мы имеем NS строка, которая фиксируется, и у нас есть NS Мутабельном строка, которая изменчива.

У нас есть массив NS. У нас есть NS Мутабельном массива и так далее. Ну у Свифта, мы не беспокоиться о том, различные версии классов. Проще говоря, если вы объявляете строку, используя Var, у вас есть изменяемый строк, потому что это переменная, так что вы можете изменить его. Если вы создаете строку, используя Пусть, тогда у вас есть Неизменное String, это постоянная и вы не можете его изменить. Как мы увидим, эта идея работает с более сложными объектами, как коллекции тоже. Мы получаем немного впереди себя. Мы не получили в объекты еще. Таким образом, мы вернемся и уточнить эту идею в дальнейшем.

Просто знайте, что рекомендация для использования позволят создать константы в Swift не только для примитивных простых видов ценностей, это за все.

Printing values and working with string interpolation

- When we're editing Swift in a playground, we can easily see the current value of any variable or constant by just writing the name of that variable or constant on some line and letting the playground show the value and the results pane on the right. But we will often want to create an output of our own more interesting messages, not just single role values. In Swift, we'll use println, print l n, to do this. This is a globally available function. There is also a print function in Swift without the ln but it ends the line break at the end so this is the one we'll usually use.

All languages need something like this. It's the equivalent of printf in C, system.out.println in Java, Console.WriteLine in C-Sharp, console.log in JavaScript. Just the way of getting a message output from your program. You could use it to write out a simple string or you could write out the value of a constant or a variable but often we'll want to combine both text and the current values of variables and constants to create a more useful message. In some languages, you would use string concatenation to do this.

Often using the plus operator to concatenate various pieces of a message together with various values. Now we can do string concatenation in Swift but there is a better way for this kind of situation. In other languages, we'd use format strings or format specifiers. Say AND C or Objective-C. We define placeholders in our string with specific date and time, and following those with the variable mains meant to replace them. Well, we don't do either of these methods in Swift. Instead, we use string interpolation.

Sidebar, string interpolation might sound like a complex term but isn't. To interpolate just means to take some existing content like a sentence or a paragraph and insert some new content somewhere into it. While these days, the word interpolation is often found in programming and Mathematics, it is not just a programming term. The word interpolation has been around for a long time. Example, if you were a scholar of ancient history, studying thousand-year-old manuscripts, and then you dig up a version that has some extra text added to it while some exhausted monk was making a copy a hundred years after the original and a historian would call that newer manuscript an interpolation.

There's been content added that wasn't in the original. But, okay, we're not changing ancient manuscripts here. What we're doing when we interpolate is introducing new content. Usually changeable, unpredictable, dynamic. I might even say variable, values, into something else. Some piece of content that already exists like an error message you need to customize, or a generated email, or a message to congratulate you on the high score you just beat, or a simple sentence to write to the system log. In Swift, it all comes down to this.

A backslash and a pair of parentheses. That's it. As long as you can remember backslash, pair of parentheses, you know how to do string interpolation in Swift. Here's how. So step one of doing string interpolation is that I have in mind some piece of text, some string literal, a message that I want to output. Like this, the high for a particular city on a particular day is some kind of temperature. When this message is output, I want to replace city, day, and temp with the values of some example variables or constants.

Let me just go ahead and add those. In step two is I then just pick each part of this string that I want to replace like city and I'll drop in a set of that backslash, pair of parentheses that I mentioned for each one. Then inside each of those parentheses, I put the name of the relevant variable or constant that I want to use to replace it. That's it! This is string interpolation. Now from writing this in a playground that will immediately see the results of this on the right hand side with this part of the string replaced by the current values of the variables or constants.

Though typically, I wouldn't just write a string literal like this by itself. Although this does work in a playground, I would usually put this inside a println statement. I'll just copy that and paste it inside. It works the same way in a playground. But this way, it would also work in a regular program where you would see the results output to the console. But it gets better because we're not limited to just showing a single value of a variable or constant inside each of these backslash and pair of parentheses.

We can also go ahead and write an expression. I'll just to drag this back so we can see it more obviously here. I got a couple of variables, quantity, and unit price. Then inside the backslash, pair of parentheses, I just directly write quantity multiplied by unit price. That expression will be evaluated. I don't need to create some temporary variable to do it. So this is string interpolation. It's a very simple, very readable format, all down to the backslash and pair of parentheses. But this is the first time we've written an expression that uses two different variables.

It introduces an important point about what happens with expressions if they have different date and times. So let's cover that next.

Printing values and working with string interpolation

Печать ценности и работать с интерполяции строк

- Когда мы редактирования Свифт в детской площадкой, мы можем легко увидеть текущее значение любой переменной или константы, просто написав имя этой переменной или константы на некоторой линии и давая площадка показать значение и панели результатов справа , Но мы часто хотим, чтобы создать выходной наших собственных наиболее интересных сообщений, а не только отдельных значений для подражания. В Свифт, мы будем использовать Println, печать Л.Н., чтобы сделать это. Это были доступны глобально функция. Существует также функция печати в Swift без Л.Н. но заканчивается разрыв строки в конце, так что это один мы обычно используем.

Все языки нужно что-то вроде этого. Это эквивалентно Printf в C, System.out.println в Java, Console.WriteLine в C-Sharp, console.log в JavaScript. Просто способ получить выход сообщение из вашей программы. Вы можете использовать его, чтобы написать простую строку или вы могли бы выписать значения константы или переменной, но часто мы хотим объединить текст и текущие значения переменных и констант, чтобы создать более полезное сообщение. В некоторых языках, вы должны использовать конкатенацию строк, чтобы сделать это.

Часто с помощью оператора плюс для объединения различных частей сообщения вместе с различными значениями. Теперь мы можем сделать конкатенацию в Swift, но есть лучший способ для этого вида ситуации. В других языках мы должны использовать форматные строки или спецификаторы формата. Скажем, В и С или Objective-C. Мы определяем заполнители в нашей строки с определенной даты и времени, и после тех с переменными сети, предназначенных для их замены. Ну, мы не сделать что-либо из этих методов у Свифта. Вместо этого, мы используем интерполяции строк.

Боковая панель, строка интерполяции может звучать как комплексное понятие, но это не так. Для интерполяции просто означает, принять какое-то существующее содержимое как приговор или абзац и вставьте новый контент где-то в него. В то время как в эти дни, интерполяция слово часто встречается в программировании и математики, это не просто термин программирование.Интерполяция слово была вокруг в течение долгого времени. Например, если вы были ученым древней истории, изучая тысячелетней давности рукописи, а затем вы выкопать версия, которая имеет дополнительный текст добавлен к ней, а некоторые исчерпаны монах, сделав копию через сто лет после оригинала и историк назвал бы это новая рукопись интерполяции.

Там было содержание добавил, что не было в оригинале. Но, ладно, мы не меняем древние рукописи здесь. Что мы делаем, когда мы интерполяции является внедрение нового содержания. Обычно изменчива, непредсказуемый, динамичный. Я мог бы даже сказать, переменных, значения, во что-то еще. Некоторые части содержимого, которое уже существует как сообщение об ошибке вы должны настроить, или сгенерированного электронной почте или сообщением, чтобы поздравить вас с высокой оценкой вы просто бить, или простого предложения писать в системный журнал. В Свифт, все это сводится к этому.

Обратная косая черта и пара круглых скобок. Это так. До тех пор, как вы можете помнить, косая черта, пару скобок, вы знаете, как это сделать интерполяции строк у Свифта. Вот как это сделать. Так, первый шаг делает интерполяции строк в том, что я имею в виду какую-нибудь текст, некоторые последовательность символов, сообщение, что я хочу на выход. Подобно этому, высока для конкретного города, на определенный день какая-то температуре. Когда это сообщение выводится, я хочу, чтобы заменить город, день и темп со значениями некоторых примерах переменные или константы.

Позвольте мне просто идти вперед и добавить таковых. На втором этапе, я тогда просто взять каждую часть этой строки, что я хочу, чтобы заменить, как город, и я брошу в наборе что обратная косая черта, круглые скобки, которые я упоминал для каждого из них. Тогда в каждом из этих скобках, я поставил имя соответствующей переменной или константы, что я хочу, чтобы использовать его заменить. Это так! Это строка интерполяции. Теперь писать это в игровой площадке, что сразу же видеть результаты этого на правой стороне этой части строки заменены текущими значениями переменных или констант.

Хотя, как правило, я бы не просто написать строку буквальное, как это само по себе. Хотя это работает в детской площадкой, я обычно ставлю бы это внутри Println заявлении. Я просто скопировать этот и вставьте его внутрь. Он работает так же, как в детской площадкой. Но этот путь, он также будет работать в рамках обычной программы, где бы вы увидеть выход, результаты на консоль. Но он становится лучше, потому что мы не ограничены только показывая единственное значение переменной или константы внутри каждой из этих обратная косая черта и парой круглых скобок.

Мы также можем идти вперед и написать выражение. Я просто перетащить эту спину, чтобы мы могли увидеть его, очевидно, здесь. Я получил несколько переменных, количество и цена за единицу товара. Тогда внутри обратную косую черту, пара круглых скобок, я просто прямо написать количество, умноженное на единицу цены. Это выражение будет вычисляться. Мне не нужно, чтобы создать некоторую временную переменную, чтобы сделать это. Так что это строка интерполяции. Это очень просто, очень для чтения формате, все, вплоть до обратной косой черты и парой круглых скобок. Но это первый раз, когда мы написали выражение, которое использует два различных переменных.

Он вводит важный момент о том, что происходит с выражениями, если они имеют другую дату и время. Так давайте рассмотрим, что в следующем.

Converting values

- Swift is a language that insists on clarity. It doesn't allow you to be vague and unspecific. We've already seen that it does type checking. We can't treat a string variable like it's an integer or the other way around and we'll see more and more of this as we go forward. This clarity is required in expressions, whether they're simple expressions in a println statement like I have here, or when we're creating another variable or in a function, Swift wants to be very specific about how to do this. Now here's what I mean, if we want to multiply together two integer variables, and these are integer variables because their initial value had nothing after the decimal point, well then this would be fine.

We multiply two Ints and we would get another integer, but if I had given one of these variables an initial floating-point value, I'll change unitPrice here, well unitPrice would now be inferred as a Double, not an Int because a Double is the default floating-point type in Swift. So in this expression we are now multiplying an integer value by a Double, by a floating-point value and Swift is going to immediately sound the alarm. We've got an error popping up over here because it isn't sure what type we want the result to be.

Do we want treat the Double as an integer and truncate it and lose what's after the decimal point or do we want to treat the integer as a Double and theoretically lose precision? Now this error is not the most straightforward. Could not find member "convertFromStringInterpolationSegment", but really the issue here is that we are trying to multiply together an integer by a Double and we're not being specific about how this should be done. And this is not just for println statements. This would work the same way if I wanted to just create a new variable based on multiplying the two of these together.

We're still going to have this issue. Quantity times unitPrice is now an integer times a Double. It's not sure how to do this. It's not sure what this result should be. Several programming languages would implicitly convert the integer here, this Quantity, and treat it as a floating-point value with the result being another floating-point value, but here's the thing that I would write in big flashing letters if I could. Swift does not and will not implicitly convert one value to another type of value. Now it is easy to convert one type of value to another.

There are simple functions to be able to do this. We've got functions like Double() that we just call, or Int() or String(), but it has to be explicit. Swift can do it easily, but it won't do it automatically, you must make it happen. This is another safety feature of Swift. If there is any potential for mismatch, for loss of information, for vagueness, then you must choose, you must be specific. So in this case when multiplying these together do I want to treat the integer as if it's a Double or the Double as if it's an integer? Well in this case I don't want to lose what's after the decimal point, so let's treat them both as Doubles.

Now it is true I could just put a .0 up here after Quantity and have that automatically inferred as a Double. You see this now works, we get rid of the error, but this is cheating. Quantity probably should be an integer. We're not going to sell .5 or .1 of a unit, so I'm going to leave that back as an Int and in the expression here what I'm going to do is wrap Quantity in a call to Double(). Now we're explicitly converting it and we have no more error.

We get our result as another Double and I could do the same thing inside the string interpolation. The expression is evaluated and we get the result here that we want. So conversion is easy to do in Swift. It just doesn't happen automatically if there is any potential for error. Now it is true that there are some conversions that throw even more potential for error. If you're trying say to convert a string value to a numeric value and the string doesn't actually hold a numeric value, well what happens? But that discussion can come later, first let's get into managing the flow of our code.

Converting values Преобразование значения

- Свифт язык, который настаивает на ясности. Это не позволит вам быть расплывчатым и неспецифические. Мы уже видели, что он делает проверку типов. Мы не можем рассматривать строковую переменную, как это целое или наоборот, и мы видим все больше и больше из этого, как мы идем вперед. Эта ясность требуется в выражениях, являются ли они простые выражения в Println заявлении, как у меня здесь, или когда мы создаем еще одну переменную или в функции, Свифт хочет быть очень конкретным о том, как это сделать. Теперь вот то, что я имею в виду, если мы хотим, чтобы перемножить два целочисленных переменных, и они целые переменные, так как их первоначальная стоимость не имел ничего после десятичной точки, а затем это было бы прекрасно.

Умножим два целых и мы хотели бы получить еще целое, но если я дал одной из этих переменных начальное значение с плавающей точкой, я изменю UnitPrice здесь, а UnitPrice теперь будет выведено в виде двойного, а не как Int, потому что Double это тип с плавающей точкой по умолчанию у Свифта. Таким образом, в этом выражении мы сейчас умножения целое число двойной, значением с плавающей точкой и Swift будет немедленно бить тревогу. Мы получили сообщение об ошибке выскакивают здесь, потому что он не уверен, какой тип мы хотим, чтобы результат.

Хотим ли мы рассматривать еще и как целое и обрезать его и потерять то, что после десятичной точки или мы хотим, чтобы лечить целое число в виде двойного и теоретически привести к потере точности? Теперь эта ошибка не самый простой. Не удалось найти член "convertFromStringInterpolationSegment", но на самом деле проблема здесь в том, что мы пытаемся перемножить целое число двойной, а мы не специфичны о том, как это должно быть сделано. И это не только для Println отчетности. Это будет работать так же, как если бы я хотел, чтобы просто создать новую переменную на основе умножения двух из них вместе.

Мы по-прежнему будем иметь эту проблему. Раз Количество UnitPrice теперь целое число раз удвоиться. Это не уверен, как это сделать. Это не уверен, что этот результат должен быть. Несколько языков программирования будет неявно преобразовать целое число здесь, эта величина, и рассматривать его как число с плавающей точкой с результатом, являющимся другое значение с плавающей точкой, но вот что я хотел бы написать в больших мигающих букв, если я мог. Swift нет и не будет неявно преобразовать одно значение другого типа значения. Теперь это легко конвертировать один тип значения к другому.

Есть простые функции, чтобы иметь возможность сделать это. У нас есть такие функции, как Double (), что мы просто называем, или Int () или String (), но она должна быть явным. Swift можете сделать это легко, но это не будет делать это автоматически, вы должны сделать это. Это еще один безопасность особенностью Свифт. Если есть потенциал для несоответствие, за потерю информации, для неопределенности, то вы должны выбрать, вы должны быть конкретными. Таким образом, в этом случае при умножении их вместе я хочу, чтобы рассматривать целое, как будто это двухместный Двухместный, как будто это число? Ну в данном случае я не хочу потерять то, что после десятичной точки, так что давайте относиться к ним как в качестве удваивается.

Теперь это правда, я мог бы просто положить 0,0 до сюда после Количество и есть, что автоматически исходя из как Double. Вы видите это теперь работает, мы можем избавиться от ошибки, но это обман. Количество вероятно, должно быть целым числом. Мы не собираемся продавать 0,5 или 0,1 из блока, так что я собираюсь оставить, что еще как Int и в выражении здесь то, что я собираюсь сделать, это обертывание Количество в вызове Двухместный () , Теперь мы явного преобразования и у нас нет более ошибку.

Мы получаем наш результат как еще один двойной, и я мог сделать то же самое внутри интерполяции строк.Выражение вычисляется и мы получаем результат здесь, что мы хотим. Так преобразование легко сделать в Свифт. Это просто не происходит автоматически, если есть потенциал для ошибки. Теперь это правда, что есть некоторые преобразования, которые бросают даже больший потенциал для ошибки. Если вы пытаетесь сказать, чтобы преобразовать строковое значение в числовое значение и шнур фактически не провести числовое значение, а то, что происходит? Но это обсуждение может прийти позже, сначала давайте в управлении потоком кода.

Writing if statements

- There's not much point having variables if you're not going to ask questions about them and their values. So let's cover the classic if statement to manage the flow of logic through our code. Now like many other things in Swift, if statements here are clean, they're safe and they're all familiar. If you've written any JavaScript, C, C++, C Sharp, PHP, Java ActionScript, I could tell you just try writing an if statement. Write what you know. What you'd write, which would be something like this, would work in Swift. It's an if statement so back as basic as it gets but come back.

See, this doesn't mean we're done here. Because for most programmers, there are a few distinctions worth making about if statements in Swift. First, you do not need parentheses around your condition, the way that you do it in many other languages. You can have them if you find it helpful or more likely if you're just so used to writing them that is habitual. But like semicolons, they're simply not necessary in Swift. With the simple condition like this, parentheses don't add anything so removing them just makes it more readable.

The next thing you need to know about if statements in Swift is that one parentheses may be optional. Curly braces aren't required for each branch of the condition. You probably already know that in many C-Star languages, if you write a simple if statement when you want to execute a single line of code if a condition is true, then you don't have to have that single statement surrounded with curly braces. You could just write code like this. But if you've programmed through any length of time, you will also know that this so-called feature of C-Star languages, once you've mixed this in 100 of lines of other code, is easy to miss and it can cause very subtle but nasty face palm, "Oh my God, I can't believe I didn't see that logic errors." So this is not an option in Swift.

Even with an if condition that only has one line to execute. When a condition is true, this is a code block. This code block must be surrounded with curly braces. You will get a compile error if you don't have one. To me, these distinctions are a perfect example of the choices made in the Swift programming language. You don't need parentheses around a simple condition because they add no value. Removing them just makes it clear and readable. You do need braces around your code blocks because they make things safer. We can, of course, follow our if statement block with an else, unless again, we'd need braces around the code block.

You could, of course, also chain multiple if statements and you could nest one inside another but don't nest too deep. Swift can certainly handle that just fine. But multiple levels of nested ifs are difficult to read and prone to making program errors. If we do have to have more complex conditions, there are more readable ways to manage it than lots of nested if statements. Now this condition must evaluate as either true or false. Now this, of course, is not unusual. I'm stressing the words true and false so the C programmers among you understand that you can not just have a condition that test and enter your value for being either zero or nonzero.

This won't work in Swift. The condition must evaluate as a Boolean. So things like if a is greater than 50, true or false. If b is less than zero, true or false. If c is equal to zero and to check equality in Swift, like most other C-based languages, we use the double equals. Single equal sign after all is assignment. It would set a value, not to check a value. You'll get an error if you accidentally try to assign inside the condition. For checking inequality, it's the exclamation mark, equal sign here.

Nothing particularly unusual about this. Likewise, we can check for multiple conditions at the same time. We can either use the logical AND operator, the double ampersand for AND, or the double pipe for the logical OR. Now when you have multiple conditions to check, this is one of the places that you may choose to add parentheses to make the condition more specific. In this case, if balance is less than zero, AND hasCreditLine, assuming this is a Boolean here, or balance is greater than or equal to zero. If either of these worked out as true, this condition will be true.

But of course, if statements aren't the only way to manage program, folks. So let's take a look at switch statements and how they work in Swift.

Writing if statements Написание если заявления

- Там не так много смысла иметь переменные, если вы не собираетесь задавать вопросы о них и их значений. Так давайте рассмотрим классический если заявление управлять потоком логики в нашем коде. Теперь, как и многие другие вещи в Swift, если заявления здесь чистой, что они в безопасности, и все они знакомы. Если вы написали какой-либо наличие, C, C ++, C Sharp, PHP, Java ActionScript, я мог бы сказать вам только попробовать написать, если заявление. Напишите, что вы знаете. То, что вы написали бы, что бы что-то вроде этого, будет работать в Swift. Это, если заявление так назад, как основные, как он получает, но вернуться.

Видите, это не значит, что мы сделали здесь. Потому что для большинства программистов, есть несколько различий стоит сделать о том, если заявления в Swift. Во-первых, вам не нужно скобки вашего состояния, так, что вы сделать это и во многих других языках. Вы можете иметь их, если вы найдете это полезным или, скорее, если вы просто так привык к их написанию, что привычно. Но, как и точка с запятой, они просто не нужны в Свифт. С простого условия, как это, круглые скобки не добавить ничего поэтому удаление их просто делает его более читабельным.

Следующее, что вы должны знать о том, если заявления в Swift является то, что один скобки могут быть необязательными. Фигурные скобки не являются обязательными для каждого филиала состоянии. Вы, наверное, уже знаете, что во многих языках C-Star, если вы пишете просто, если заявление, если вы хотите, чтобы выполнить одну строку кода, если условие истинно, то вы не должны иметь, что один оператор в окружении фигурных скобках , Вы можете просто написать код, подобный этому. Но если вы программировали через какое-то время, вы также знаете, что эта так называемая функция C-Star языках, как только вы смешивали это в 100 строк другой код, легко пропустить, и это может привести к очень тонкий, но противно лицо ладонью, "О, мой Бог, я не могу поверить, что я не видел, что логические ошибки." Так что это не вариант в Свифт.

Даже с, если при условии, что имеет только одну строку для выполнения. Когда условие истинно, это блок кода. Этот код блок должен быть окружен фигурными скобками. Вы получите ошибку компиляции, если вы не один. Для меня эти различия прекрасный пример того, что выбрано в Свифт языка программирования. Вам не нужно скобки вокруг простых условий, потому что они не добавляют никакой ценности. Удаление их просто ясно и читаемым. Вам нужно скобки вокруг ваших блоков кода, потому что они делают вещи более безопасным. Мы можем, конечно, последовать нашему, если заявление блок с другой, если мы снова не понадобится скобки вокруг блока кода.

Можно, конечно, тоже объединять несколько если заявления, и вы можете вложить одна в другую, но не гнездятся слишком глубоко. Swift, безусловно, может справиться с этим очень хорошо. Но несколько уровней вложенных IFS трудно читать и склонны делать ошибки программы. Если мы должны иметь более сложные условия, есть более читаемые способов управления его чем большим количеством вложенных если заявления. Теперь это условие должно оценить как истинное или ложное. Теперь это, конечно, не является необычным. Я подчеркиваю слова истинные и ложные, так программистов C из вас понять, что вы не можете просто условии, что тест и введите значение за то, что либо нулю, либо отлична от нуля.

Это не будет работать в Swift.Состояние должны оценить как логическое значение. Так вещи, как если больше 50, истинным или ложным. Если б меньше нуля, истинным или ложным. Если с равно нулю и проверить равенство у Свифта, как и большинство других C-основе языков, мы используем двойные равных. Одноместный знак равенства ведь это назначение. Было бы установить значение, не проверить значение. Вы получите ошибку, если вы случайно попытаетесь присвоить внутри состоянии. Для проверки неравенства, это восклицательный знак, знак равенства здесь.

Ничего необычного об этом. Кроме того, можно проверить несколько условий одновременно. Мы можем либо использовать логический оператор И, двойной амперсанд для AND, или двойной трубы для логического ИЛИ. Теперь, когда у вас есть несколько условий, чтобы проверить, что это одно из тех мест, которые вы можете выбрать, чтобы добавить скобки, чтобы сделать состояние более конкретной. В этом случае, если баланс меньше, чем ноль, и hasCreditLine, при условии, что это логическое здесь, или остаток больше или равно нулю. Если какой-либо из них работал, как правда, это условие будет истинным.

Но, конечно, если заявления не являются единственным способом управлять программой,, люди. Итак, давайте взглянем на переключателе отчетности и как они работают у Свифта.

Using the switch statement

- When you realize you're writing code that repeatedly checks one variable from multiple different values, perhaps something like this, then a switch statement is a better idea than having multiple if statements, just one after the other. Now just as with if statements, if you've worked in any other language that has the switch keyword, then writing a basic switch statement in Swift isn't drastically different, and you would probably find this code fairly readable and understandable. But just as with the if statements, there are important things to know, things that are true about switch statements in Swift that are not true in other languages.

Alright, so basic syntax, if this is new to you or if you need a refresher. Whenever you see a switch statement, you know you're evaluating a single item, whether that's a variable or a constant, and you're reacting to multiple possible values of that. So let's imagine we've got an integer called windSpeed that could be something in the range zero through twelve. So to check this using a switch statement, it begins simply. Just the keyword switch and the name of the piece of data that we want to check, some variable, some constant. And then a set of opening and closing curly braces.

But when we write a switch statement, we don't have just one important keyword, but two. Switch and case because inside this code block for each switch we will have multiple case keywords. That's how we say what different values we want to check for and react to. Each case ends with a colon, not a semi-colon. And this colon is not optional like the semi-colons are at the end of a statement, so watch out for that. So we'll have multiple cases. So we're switching on the windSpeed variable. We say in the case that it's zero, do one thing.

In the case that it's one, do something else. In case it's two, do yet another thing, etc., etc. Now after each case and after the colon, we then have one or more lines of code that will execute if that case is true. And in Swift, as soon as we hit the first case that is true, we will execute that case and then we're done with the switch statement. We would drop out to the end, past the final closing curly brace of the switch, and continue on. Nothing particularly unusual about any of this if you've worked with switch statements in other languages.

Having said that, if I wrote code like this in a playground, this would not compile in Swift yet. Here's why. First, a switch statement in Swift must be exhaustive. What this means is if you're testing, say an integer constant, as we are here, you can't just have a handful of cases for a few specific values and just ignore all the other possible values that this integer could possibly be. You need to make sure that all possible values are handled in the switch. In my case, I may know that my logic means I'm only ever going to have values from zero through twelve, so I'd provide those cases, but this is, after all, an integer, and I've got several billion more values this could be.

Now the simplest way of dealing with this inside a switch is to have a default case. We just use the keyword default with a colon. We don't actually need the case keyword here, and this allows us to have a catch-all situation. Default simply means all the other cases weren't true, so do this. Now in some languages, like objective C and regular C, you will often see code with several empty cases written in them, one right after the other. This uses the concept of fall through that exists in some languages.

We would fall through from one case into the next, effectively sharing code across multiple cases. And in languages that do have this fall through behavior, you often need an explicit break statement at the end of the code for each case so that you don't just go and fall through into the next case, so in case 3 and case 4 they end with a break statement here. But fall through is another thing that can cause hard-to-find bugs, So in Swift, by default, there is no automatic, no implicit fall through from one case to another.

And that means each case must have it's own code, its own functionality. Empty cases like what I'm writing here, wouldn't compile in Swift. It would complain about them. We need to have at least one statement to execute in each of these cases. And in Swift, as soon as we hit a case that's true, we'll execute the statements in that case, and then we're done. We jump to the end of the switch statement and continue on. Now if you do have a situation where you wanted to explicitly do nothing in a particular case, you can write a break statement in Swift.

So, for example here, if I wanted to have the default case didn't do anything, I'd put that in and I'd put break. But these are only needed when you need to explicity end a case, either by itself, or if you had some logic, some branching, going on inside that case. So while we can't write empty cases one after another, we can test for multiple values, and one of the best ways of doing it in Swift is that we can provide ranges of values to check for. Now this is something that isn't possible in the switch syntax of many other languages.

So if I want to test this integer to see if it's somewhere between zero and three, I would write this. case 0...3. These three dots is what's called a range operator in Swift. This is a very concise way of saying, create a range with the values on both sides of the ... and all the values in between. So here any value from zero through three, or from four through six, or seven through nine, or ten through twelve, will count as true for this case.

Now this is known as the closed range operator. There are two range operators in Swift. This is one of them, we'll see the other one in a moment because they're not just important for switch statements. They're also extremely useful when creating loops. Now there are some advanced features of switch statements in Swift that can take this even further, like using where clauses and creating temporary variables, but we'll see these a little later on. This is enough to keep us moving forward. So these are the important things to understand, particularly when coming from another language with switch statements.

That they must be exhaustive in Swift, and all values handled somewhere in the code. That we can provide ranges of values to check on, and that each case must contain at least one statement. There is no automatic or implicit fall through in Swift from one case to the next. And as soon as we hit a case that's true, we'll execute just the code in that case, and then we're done. We jump out of the switch statement and move on. So let us move on and create some loops.

Using the switch statement Использование Переключатель

- Когда вы поняли, что вы пишете код, который неоднократно проверяет одну переменную из нескольких различных значений, возможно что-то вроде этого, то Переключатель является лучшей идеей, чем, имеющих несколько если заявления, только один за другим. Теперь же, как с если заявления, если вы работали на любом другом языке, который имеет ключевое слово переключателя, то писать базовый о переключателя в Swift не сильно отличается, и вы, вероятно, найти этот код довольно читаемым и понятным. Но так же, как с если заявления, Есть важные вещи, чтобы знать, вещи, которые истинны о переходе отчетности в Swift, которые не так в других языках.

Хорошо, так Базовый синтаксис, если это для вас в новинку, или если вы хотите освежить в. Всякий раз, когда вы видите Переключатель, вы знаете, что оценки одного элемента, будь то переменная или константа, а вы реагируете на несколько возможных значений этого. Итак, давайте представим, что у нас есть целое число, называемое скорость ветра, что может быть что-то в диапазоне от нуля до двенадцати лет. Таким образом, чтобы проверить это с помощью Переключатель, она начинает просто. Просто переключатель ключевых слов и название части данных, которые мы хотим проверить, какой-либо переменной, некоторая константа. И тогда набор открытия и закрытия фигурные скобки.

Но когда мы пишем Переключатель, мы не имеем только один важное ключевое слово, а два. Переключатель и так, потому что внутри этого блока кода для каждого коммутатора мы будем иметь несколько ключевых слов дело. Вот как мы говорим, что различные ценности, которые мы хотим проверить и реагировать на. Каждый случай заканчивается двоеточием, а не запятой. И этот знак является обязательным, как полу-двоеточия в конце заявления, так что следите за этим. Таким образом, мы будем иметь несколько случаев. Таким образом, мы включением переменной скорости ветра. Мы говорим в том случае, это ноль, сделать одну вещь.

В случае, если это один, что-то еще. В случае, если это два, сделать еще один предмет, и т.д., и т.д. Теперь, после каждого случая и после толстой кишки, тогда имеем один или несколько строк кода, которые будут выполняться, если в этом случае верно. И у Свифта, как только мы попали в первом случае это правда, мы выполним это дело, а затем мы сделали с Переключатель. Мы бросаем бы до конца, мимо окончательного закрытия фигурной скобки переключателя, и продолжать. Ничего необычного обо всем этом, если вы работали с коммутатора заявлений на других языках.

Сказав, что, если бы я написал такой код в детской площадкой, это не будет компилировать в Swift еще. Вот почему. Во-первых, Переключатель в Swift должен быть исчерпывающим. Что это означает, если вы тестируете, скажем, целая константа, а мы здесь, вы не можете просто есть несколько случаев в течение нескольких конкретных значений и просто игнорировать все другие возможные значения, что это число могло бы быть. Вы должны убедиться, что все возможные значения обрабатываются в коммутаторе. В моем случае, я буду знать, что моя логика означает, что я только когда-нибудь иметь значения от нуля до двенадцати лет, так что я бы предоставить эти случаи, но это, в конце концов, число, и я получил несколько миллиардов более значений, это может быть.

Теперь простой способ борьбы с этим внутри выключателя, чтобы иметь дело умолчанию. Мы просто использовать по умолчанию ключевое слово с двоеточием. Мы на самом деле не нужно случай ключевое слово здесь, и это позволяет нам иметь всеохватывающий ситуацию. По умолчанию просто означает, что все остальные случаи не были правдой, так это сделать. В настоящее время в некоторых языках, как объективной С и регулярной C, вы часто будете видеть код с несколькими пустыми случаях в них написано, один за другим. При этом используется понятие падения через это существует в некоторых языках.

Мы падаем бы через от одного случая в следующем, эффективного обмена кодом на нескольких случаях. И в языках, есть осенью этого года через поведение, часто нужно явное заявление перерыв в конце кода для каждого случая, чтобы вы не просто пойти и провалиться в следующем случае, так и в случае 3 и случае 4 они заканчиваются распадом заявлении здесь. Но провалиться Другое дело, что может привести к трудно найти ошибки, так у Свифта, по умолчанию, нет автоматический, никаких неявных падение через от одного случая к другому.

И это означает, что каждый случай должен иметь свой собственный код, своя функциональность. Пустые случаи, как то, что я пишу здесь, не собрать у Свифта. Было бы жаловаться на них. Мы должны иметь по крайней мере один оператор для выполнения в каждом из этих случаев. И у Свифта, как только мы попали случай, правда, мы все инструкции выполняются в этом случае, а затем мы сделали. Мы перейти к концу Переключатель и продолжать. Теперь, если у вас есть ситуации, когда вы хотели, чтобы явно ничего в конкретном случае, вы можете написать заявление перерыва в Свифт.

Так, например здесь, если бы я хотел, чтобы дело по умолчанию ничего не делать, я бы поставил, что в и я бы поставил перерыв. Но это только необходимы, когда нужно в явной форме завершить дело, либо сам по себе, или если у вас какая-то логика, некоторые ветвление, происходит внутри этого дела. Таким образом, хотя мы не можем написать пустые случаях за другим, мы можем проверить несколько значений, и один из лучших способов сделать это у Свифта является то, что мы можем предоставить диапазоны значений для проверки для. Теперь это то, что не возможно в синтаксисе переключателя многих других языках.

Так что, если я хочу, чтобы проверить эту целое число, чтобы увидеть, если это где-то между нулем и три, я хотел бы написать это. случай 0 ... 3. Эти три точки является то, что называется диапазон оператор в Свифт. Это очень краткий способ сказать, создать ряд со значениями по обеим сторонам ... и всех значений между ними. Так вот любое значение от нуля до трех, или четырех до шести или семи до девяти или десяти через двенадцать, будет считаться истинным для этого случая.

Теперь это известно как оператора замкнутую область. Есть два оператора дальности в Свифт. Это один из них, мы увидим другую в момент, потому что они не только важно для коммутаторов отчетности. Они также чрезвычайно полезны при создании петель. В настоящее время существует несколько расширенные возможности коммутаторов отчетности в Swift, которые могут воспользоваться этой еще дальше, как с помощью которых положения и создания временных переменных, но мы их рассмотрим немного позже. Этого достаточно, чтобы держать нас двигаться вперед. Таким образом, эти важные вещи, чтобы понять, особенно когда из другого языка с переключателем отчетности.

То, что они должны быть исчерпывающими Свифт, и все значения обработана где-то в коде. То, что мы можем предоставить диапазоны значений, чтобы проверить, и что каждый случай должен содержать, по крайней мере, одно заявление. Там нет автоматического или неявной падение через у Свифта от одного случая к другому. И как только мы попали случай, правда, мы выполнение только код в этом случае, а затем мы сделали. Мы выходим из Переключатель и двигаться дальше. Итак, давайте двигаться дальше и создать несколько петель.

Creating loops in Swift

- Swift, being a C influenced language, has the keywords you would probably expect for creating loops. We've got while, do while, and for. Although, there are two kinds of for loops in Swift. First, if you're familiar with the classic C style for loop with the initializer, condition, and increment all set up at the top, separated by semicolons, you can certainly do this in Swift. I'm not actually going to say much about this one, but the only difference is you don't need the parenthesis around the three parts of this. Of course, you'll be using Var to set up an index variable, because while this version does work fine, there is an alternative in Swift that's often preferable, which is the for-in loop.

This works great for iterating over a sequences of numbers, works wonderfully with any collection, like going through all the elements in an array, or even all the characters in a String. So, the basic format of a for-in loop is for each item in some collection. So, for each number in a range of numbers, for each element in some array. So, here's an example of a loop that iterates from one to 100. I'm using the name index here, so for index in 1...100, but this name is up to us.

If we're iterating over a range of numbers, Swift lets us use any name. This could be index, I, idx, (fu), X, whatever. It recognizes this will need to be an integer, so each time around the loop this integer variable would contain the current value, in this case from one to 100. I am using a Swift range operator, again, the three dots we saw previously with the switch statement. So, the three dots is the closed range operator. It creates a sequence that includes the numbers on both side of the three dots.

This is a closed inclusive range. When you are iterating around and using an index, it is common to want ranges that start at zero, particularly, when working with zero based collections like arrays. We can certainly do that with the closed range operator here. I would just be changing the first number to a zero. So, this would be zero through 100 including both zero and 100. This would be 36 through 99, including both of those numbers, or we could go zero through some variable, like the length of an array.

I mentioned earlier that there were two range operators in Swift. So, the other one, instead of three dots, we use two dots and a less than sign. This still creates a range using the numbers on either side. The only difference between the two, and you can remember this from the less than sign, is that the half-open range operator, the dot dot less than, does not include the number on the right. It goes up to one less than the number on the right. So, this would go from zero to 99, including both zero and 99, from 36 to 98, from zero to one less than the count of an array.

The main reason for this second version, the main reason for the half-open range operator is that, when we work with zero based collections like arrays, we typically can get the length of the array, however many items are in that. So, we will want a loop that can start at zero but go up to one less than the current length of the array. This is the way that you would do it. For-in loops don't actually have to go through a sequence of integers. I could also write something like this, to create a String of our name equal to Bob, then say for each Char in name.

Swift will look at this, realize we're not iterating of a range of numbers, we are treating a String as a collection, and it will take it as a collection of characters. It'll take each letter in turn in String and just write those out. Notice, that we don't have to keep track of an index. We don't have to keep track of the length of the String, it just works. As we'll see when we cover arrays in dictionary's, for-in loops just work with those as well. Moving onto while loops. Now, there's nothing remarkable about while loops in Swift.

It's about as simple as it gets. The format is the very straight-forward simple one you would see everywhere else in any other C style language. The keyword while, then your condition, then a set of curly braces. The most noticeable difference is that then, again, just like if statements in Swift, you do not need parenthesis around your condition. You do, not surprisingly, need curly braces around the body of the loop. As with if statements, the condition must evaluate is true or false, and as long as it's true, we will just keep on doing whatever's in the curly braces.

Whatever's in the body of the loop. Other than that, pretty standard while loop. There is also the do while loop in Swift. As with other languages, we're removing the condition to the end of the loop. As in other languages, the one important factor always remember about do while is that we will always execute the body of the loop as least once, before the condition is ever looked at. So fairly conventional stuff there. Let's go on to talk about functions, because functions in Swift certainly are different from many other languages.

Creating loops in Swift Создание петель в Swift

- Свифт, будучи под влиянием языка C, имеет ключевые слова, вы, вероятно, ожидать создания петель. У нас есть время, сделать в то время, и. Хотя, есть два вида для петель в Свифт. Во-первых, если вы знакомы с классическим стиле Си для петли с инициализации, условия и приращения все настроено на вершине, через точку с запятой, можно, конечно, сделать это в Свифт. Я на самом деле не собирается много говорить об этом, но только разница в том, что вам не нужно скобки вокруг трех частях. Конечно, вы будете использовать Var, чтобы создать индексную переменную, потому что в то время как эта версия действительно работает хорошо, есть альтернатива в стремителен, что часто предпочтительным, что для в цикл.

Это отлично подходит для итерации по последовательности чисел работает, работает чудесно с любой коллекции, как пройдя через все элементы в массиве, или даже все символы в строке. Таким образом, основной формат петли для заезда для каждого элемента в какой-то коллекции. Таким образом, для каждого числа в диапазоне чисел, для каждого элемента в некотором массиве. Итак, вот пример цикла, который перебирает от одного до 100. Я использую индекс имя здесь, так и для индекса в 1 ... 100, но это название до нас.

Если мы перебором диапазон чисел, Swift позволяет нам использовать любое имя. Это может быть индекс, I, IDX, (фу), X, что угодно. Он признает это должны быть целым числом, так что каждый раз вокруг петли это целая переменная будет содержать текущее значение, в данном случае от одного до 100. Я использую Swift оператор диапазона, опять же, три точки мы видели ранее спереключатель. Таким образом, три точки является оператор замкнутую область. Это создает последовательность, которая включает число по обе стороны от трех точек.

Это закрытый включено диапазон. Когда вы итерации вокруг и с использованием индекса, он является общим хотят диапазоны, которые начинаются с нуля, особенно при работе с нулевыми коллекций, основанных как массивы. Мы можем, конечно, сделать это с замкнутым оператором здесь. Я бы просто изменив первую цифру в ноль. Таким образом, это будет от нуля до 100, включая в нуль, а 100. Это будет 36 до 99, в том числе и из тех чисел, или мы могли бы пойти от нуля до некоторой переменной, например, длина массива.

Я уже упоминал, что было два оператора дальности в Свифт. Таким образом, другой, вместо того, чтобы три точки, мы используем две точки и менее знаком. Это создает еще ряд использованием номера по обе стороны.Единственное различие между ними, и вы можете помнить об этом от менее знаком, является то, что оператор полуоткрытый диапазон, точка точка менее, не включает в себя ряд справа. Само до одного меньше, чем число справа. Таким образом, это будет идти от нуля до 99, в том числе в нуль, а 99, от 36 до 98, от нуля до единицы меньше, чем счетчик массива.

Основной причиной для этого второй версии, основной причиной для оператора полуоткрытой диапазона является то, что, когда мы работаем с нулевыми коллекций, основанных как массивы, мы, как правило, можно получить длину массива, однако многие пункты в этом. Таким образом, мы хотим, цикл, который может начать с нуля, но подняться на единицу меньше, чем текущая длина массива. Это путь, который вы могли бы сделать это. Для в петли на самом деле не нужно идти через последовательность целых чисел. Я мог бы написать что-то вроде этого, чтобы создать цепочку от нашего имени, равной Боба, то говорят, для каждого Чаре по названию.

Swift будет смотреть на это, понимаешь, что мы не повторяя диапазона чисел, мы рассматриваем в строку, как коллекции, и это займет его как совокупность знаков. Это займет каждую букву в свою очередь, в строку, а просто написать таких проблем. Обратите внимание, что мы не должны следить за индексом. Мы не должны следить за длиной строки, он просто работает. Как мы увидим, когда мы покрываем массивы в словаре, за-петлями просто работать с теми, также. Переходя к в то время как петли. Теперь нет ничего примечательного, а петли в Свифт.

Это примерно так же просто, как оно получает.Формат очень прямо вперед проста вы увидите повсюду на любом другом языке C стиле.В то время как ключевое слово, то ваше состояние, то в фигурные скобки.Наиболее заметным отличием является то, что тогда, опять же, как и если заявления в Swift, вам не нужно скобки вокруг вашего состояния. Вы не удивительно, что необходимо в фигурные скобки тела цикла. Как если заявления, условие должно оценить истинно или ложно, и так долго, как это верно, мы просто продолжать делать что бы ни в фигурные скобки.

Что бы ни в теле цикла. Кроме этого, довольно стандартный в то время как петли. Существует также делать во время цикла в Свифт. Как и в других языках, мы удаление состояние в конце цикла. Как и в других языках, одним из важных факторов всегда помнить о делать, пока что мы всегда будем исполнять тело цикла, как минимум один раз перед состояние когда-нибудь смотрели на. Так достаточно условна вещи там. Давайте перейдем к поговорим о функциях, поскольку функции у Свифта, безусловно, отличается от многих других языках.

Defining functions

- As in all languages in Swift we want to take sections of our code and wrap the up into modular, reusable pieces, giving those pieces a name. So here is how we write and call our own functions. Now for those of you who are pure object oriented folks and you're trumping up a bit to define your own classes and thinking "Well, I don't need no stinking functions, "everything I write will be a method of a class." Well let me assure you, we'll get to that very soon. But for now assume that everything I'm about to say in the next few minutes about functions is 100 percent relevant when we create our own classes.

So in Swift the necessary keyword is func, so first here's the simplest kind of function, one that takes no input and returns no value, it just performs some behavior. Now notice I have a set of empty parenthesis after the function name, parenthesis may be optional in many places in Swift, but not here. These parenthesis have meaning, I'm being explicit that my function has no input parameters and by convention we use CamelCase for function names in Swift.

Now to call this, not surprisingly, we simply use the function name and again, parenthesis are required when calling to explicitly say we are attempting to pass no values into this function. So, let's next add an input parameter so that we can pass a value inside. So, we've got a function definition and inside the parenthesis we provide information about what data we are passing in, we must provide a name and a type for each parameter and we use the colon here, the type annotation, the same way as when defining variables and constants in Swift, the colon means "is type of", so here our input parameter called name is of type String.

So we can then use that parameter inside the body of the function and to call it you just pass in a literal or a variable of the right type. Now if we wanted to define multiple input parameters what you're going to do then is just separate them with a comma, but both of them need both a name and the type separated by the colon. When calling a function defined this way we just pass in the right data separated by a comma. However there is a vital point to understand about parameters in Swift, folks.

Remember I've said how important constants are in Swift, well by default an input parameter to a function is treated as a constant, not a variable. Let me say that again in Swift, by default, an input parameter is a constant, not a variable, so if I wrote a function definition like this, where we're passing in an input parameter called age and it's of type Int if i try and change that, I'm going to get a compile error because this parameter is a constant.

If I do need to change this value, I could either create a new variable inside my function and copy the value in or there is an option to explicitly make an input parameter into a variable by adding in the keyword var in front of it in the parameter list. It's yet another place where Swift is very specific and will default to immutable values or unchangeable values unless you explicitly tell it otherwise. Next up, if this is how we pass information in, how do we return a value form our function? In many C style languages, you write your return types at the beginning of the function, but not in Swift.

In Swift, the return type of the function comes after any input parameters are defined, so after the parenthesis whether or not we are passing any information into this, we then add a return arrow, the dash and greater then sign and after that, the type, are we returning a string, are we returning an integer, whatever needs to be returned. We don't need a name here, we just need a type. So when you are reading through Swift code it is this return arrow that is the indicator that this function returns a value of some kind.

If you have this return arrow, your function then must have a reachable return statement that will actually return a data type of this kind. So we then call it and we could accept the value coming back from this function into a variable or a constant or we could just use the result of calling this directly in some other statement, like here, a println statement. So next up, how about defining a default value for an input parameter and this is very easy to do but it will require a slight change when we are calling the function. Here's what I mean by that, we begin with a simple function called myFunction, inside the parameter list I'm going to have a parameter of type String and then use the equals John Doe to provide this default initial value, this looks very similar to defining a variable although interestingly type inference does not occur here, I cannot omit the colon type when you're defining the parameters.

So how about when we call this function, well here is the interesting thing, if I just try and call it and pass in a value, this would have worked before we provided the default value but will no longer work now. The important point to understand is that when you start to add default values into your function definitions, and you then want to call the function but not use the default value, you must then name your argument. So this is what I mean by that, we can just call the function passing in nothing, that's perfectly acceptable it will then use the default value of John Doe.

If I want to call it and pass in a value to replace that default, I must provide a named argument, we must use the name of the parameter, in our case it is name, then a colon, then the value, we must explicitly name this piece of data, telling Swift what parameter this value is intended for. Now, this might seem a little odd, having to name our parameters when calling our function, after all there is only one parameter in this function, surely it should understand what this piece of data is intended for, but the reason for this is that if we have multiple parameters defined in a function, let's say we have a function defined with two parameters, a and b, both being given default values of 10 and 50 and then when we call it, what happens if we just pass in a single value? In this case passing in 99, is that meant to replace the default value of a or of b? So this would give you a compile error, you can pass in a single value and you could do it for a, so a:99 or one for b which is 200 or you could pass in a and b, naming both of those parameters, but as soon as you start providing default values for your parameters you need to name the information when you are passing it in.

Some languages might support the optional values by having commas and leaving values blank, but in Swift the way we do that is not only naming parameters when defining the function, but naming our arguments when calling our function. Now thankfully, Xcode will help you autocomplete this information once your functions are defined, so it's very easy to write and it does make for very readable code, this is one of the few nods in Swift to Objective-C where you also name your arguments when calling methods All right, so there are more things that we can do with functions but this is certainly enough to move on and in the next section we're going to move past basic strings and integers and start to explore more complex types in Swift like collections and working with typles and closures.

Defining functions Определение функции

- Как и во всех языках в Swift мы хотим, чтобы разделы нашего кода и обернуть вверх в модульных, многократно используемых частей, давая те части имени. Так вот, как мы пишем и призываем наших собственных функций. Теперь для тех из вас, кто являются чистыми объектно-ориентированных людей, и вы побеждает немного, чтобы определить свои собственные классы и думать: "Ну, я не нуждаемся ни в вонючие функции", все, что я пишу, будет метод класса. "Ну позвольте мне заверить вас, мы вернемся к этому очень скоро. Но сейчас предположим, что все, что я собираюсь сказать в ближайшие несколько минут о функциях на 100 процентов актуально, когда мы создаем наши собственные классы.

Таким образом, в Swift необходимо ключевое слово FUNC, поэтому сначала вот простейший вид функции, один не принимает никакого ввода и не возвращает никакого значения, это просто выполняет некоторые поведение. Теперь обратите внимание у меня есть набор пустых скобках после имени функции, скобки могут быть необязательными во многих местах в Swift, но не здесь. Эти скобки имеют смысл, я явное, что моя функция не имеет входных параметров и в соответствии с соглашением мы используем верблюжьего для имен функций в Свифт.

Теперь, чтобы назвать это, не удивительно, что мы просто используем имя функции и снова, скобки необходимы при вызове явно сказать, что мы пытаемся не проходить никаких значений в этой функции. Итак, давайте затем добавьте входной параметр так, что мы можем передать значение внутри. Таким образом, мы получили определение функции и внутри скобок мы предоставляем информацию о том, что данные, которые мы передаем, мы должны указать имя и тип каждого параметра, и мы используем двоеточие здесь, аннотации типа, так же, как при определении переменных и констант в Swift, толстой кишки означает "является тип", так вот наш входной параметр называется имя типа String.

Итак, мы можем затем использовать этот параметр в теле функции, и назвать его просто проходят в буквальном или переменной соответствующего типа. Теперь, если мы хотели, чтобы определить несколько входных параметров, что вы собираетесь сделать, это просто разделите их запятой, но оба из них нужно как имя и тип, разделенные двоеточием. При вызове функции, определенные таким образом, мы просто пройти в нужных данных, разделенных запятыми. Однако есть важный момент, чтобы понять о параметрах в Swift, ребята.

Помните, я уже говорил, как важно константы у Свифта, а по умолчанию входной параметр в функцию рассматривается как постоянное, а не переменная. Позвольте мне сказать, что снова у Свифта, по умолчанию, входным параметром является константой, а не переменной, так что если я написал определение функции, как это, где мы проходим в качестве входного параметра под названием возраста, и это типа Int, если я попытаться изменить это, я иду, чтобы получить ошибку компиляции, потому что этот параметр является константой.

Если мне нужно изменить это значение, я мог бы создать новую переменную внутри моей функции и скопировать значение или есть возможность явно указать входной параметр в переменную, добавив в вар ключевое слово перед ним в список параметров. Это еще одно место, где Swift очень специфичен и по умолчанию будет непреложных ценностей или неизменных ценностей, если только вы явно не скажете иначе. Затем, если это, как мы передать информацию в, как мы возвращаемся значение формируют нашу функцию? Во многих языках C стиль, вы пишете типы возвращаемых в начале функции, но не у Свифта.

В Свифт, тип возвращаемого значения функции наступает после каких-либо входные параметры определены, так что после скобках или нет мы передаем любую информацию в это, мы затем добавить обратный стрелку, тире и больше, то знак, и после этого, тип, мы возвращая строку, мы возвращая целое число, независимо должен быть возвращен. Нам не нужно здесь имя, мы просто должны тип. Поэтому, когда вы читаете через SWIFT-код это такое возвращение стрелка, которая является показателем того, что эта функция возвращает значение некоторого типа.

Если у вас есть этот обратный стрелку, ваша функция, то должны быть достижимой возврата заявление, что будет на самом деле возвращать тип данных такого рода. Таким образом, мы затем вызвать его, и мы могли принять значение Возвращаясь из этой функции в переменной или постоянной, или мы могли бы просто использовать результат вызова этого прямо в некоторое другое утверждение, как здесь, в Println заявлении. Так что в следующий вверх, как об определении значения по умолчанию для входного параметра, и это очень легко сделать, но для этого потребуется небольшое изменение, когда мы вызываем функцию. Вот что я имею в виду, что мы начнем с простой функции под названием MYFUNCTION, внутри списка параметров я буду иметь параметр типа String, а затем использовать равняется John Doe, чтобы обеспечить этот начальное значение по умолчанию, это выглядит очень похоже на определяя переменную хотя интересно вывод типа не происходит здесь, я не могу опустить тип толстой кишки, когда вы определяете параметры.

Так как о том, когда мы называем эту функцию, ну вот интересная штука, если я просто попробовать и назвать его и передать в значении, это сработало бы, прежде чем мы условии, значение по умолчанию, но больше не будет работать.Важным моментом, чтобы понять, что когда вы начинаете добавить значения по умолчанию в определениях функций, а затем вы хотите вызвать функцию, но не использовать значение по умолчанию, то вы должны назвать свой аргумент. Так это то, что я имею в виду, что мы можем просто вызвать функцию передавая ничего, что вполне приемлемо то будут использоваться значения по умолчанию John Doe.

Если я хочу, чтобы назвать это и передавать значение для замены, что по умолчанию, я должен предоставить именованный аргумент, мы должны использовать имя параметра, в нашем случае это имя, затем двоеточие, затем значение, мы должны явно назвать эту часть данных, рассказывая Swift что параметр предназначен это значение для. Теперь, это может показаться немного странным, имея назвать наши параметры при вызове нашу функцию, в конце концов есть только один параметр в этой функции, конечно, он должен понять, что это часть данных предназначена для, но причина этого заключается в том, что Если у нас есть несколько параметров, определенных в зависимости, скажем, у нас есть функция, определенная с двумя параметрами, а, б, причем оба заданные значения по умолчанию 10 и 50, а затем, когда мы его называем, что произойдет, если мы просто передать в единый ценность? В этом случае, проходящей в 99, является то, что заменяет значение по умолчанию для или B? Так что это даст вам ошибку компиляции, вы можете передать в одном значении, и вы могли бы сделать это для, так: 99 или один для Ь, 200 или вы можете перейти в А и В, назвав оба этих параметров, но как только вы начинаете, содержащая значения по умолчанию для параметров нужно назвать информацию, когда вы передаете его в.

Некоторые языки могут поддерживать дополнительные значения, имея запятые и оставив значения пустой, но у Свифта, как мы делаем, не только называя параметров при определении функции, но называя наши аргументы При обращении в нашу функцию. Теперь к счастью, Xcode поможет вам автозаполнения эту информацию только ваши функции определены, так что это очень легко писать и делает для очень читаемый код, это один из немногих кивает Свифт Objective-C, где вы также называют свои аргументы при вызове методов Ладно, есть еще вещи, которые мы можем сделать, с функциями, но это, конечно, достаточно, чтобы двигаться дальше и в следующем разделе мы собираемся двигаться мимо основных строк и целых чисел и начать исследовать более сложные типы в Swift как коллекций и работы с typles и закрытия.