Тип референции: 1. Тип референции

1. Тип референции

Практическое занятие «Анализ метапрограмм»

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

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

Существуют несколько метапрограмм, которые могут иметь существенное значение для успешности потенциального сотрудника в организации, в том коллективе и окружении, в котором ему предстоит работать. Рассмотрим некоторые из них, такие как:

1. тип референции;

2. стремление – избегание;

3. процесс – результат;

4. сходство – различие;

5. склонность к позиционированию себя в рабочих отношениях: «одиночка» — «менеджер» – «командный игрок»;

6. содержание – окружение;

7. активность – рефлективность.

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

Тип референции показывает, каким образом соотносится собственное и чужое мнение при принятии решений и самооценке человека.

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

Определение типа референции наиболее оправдано в виде шкалы, на которой позиционируется тяготение человека к тому или иному типу или баланс.

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

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

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

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

Предположим, что вы ответили на 10 вопросов и получили следующие результаты:

5/5 – баланс. Очень хорошо для сотрудников, выполняющих содержательно сложные виды работ, требующие периодического принятия самостоятельных решений, в то же время сильной ориентации на людей (менеджер по работе с ключевыми клиентами, торговый представитель, развивающий новое направление, сотрудник отдела логистики, финансовый аналитик, бухгалтер среднего звена).

6-7 (внутренняя)/ 4-3 (внешняя). Руководящая работа среднего уровня, требующая частого принятия самостоятельных решений, умения отстаивать свою точку зрения и в то же время учитывать поведение и желания партнеров и (или) групповую динамику (руководитель среднего звена, менеджер по персоналу, тренер, руководитель проектов).

8-9 (внутренняя) / 2-1 (внешняя). Руководящая работа высокого уровня, некоторые виды контролирующих работ, требующие умения, учитывая разные варианты, настаивать на правильной стратегии и сопротивляться давлению и манипуляциям.

10 (внутренняя). Смотри предыдущий вариант.

3-4 (внутренняя) / 7-6 (внешняя). Работа, связанная с сильной ориентацией на других людей, не связанная с постоянно требующимся умением отстаивать свою точку зрения и вести себя достаточно независимо (торговый представитель, работающий с постоянными клиентами, секретарь, младший бухгалтер и т.д.).

0-2 (внутренняя) / 10 –8 (внешняя). Исполнительская работа, требующая хорошей управляемости и практически никогда не требующая отстаивания своей позиции.

Тип референции[3]. Развитие потенциала сотрудников. Профессиональные компетенции, лидерство, коммуникации

Тип референции[3]

Тип референции – одна из характеристик, знание которой позволит определиться с тем, какой вариант коучинга будет наиболее оптимальным для конкретного человека.

Сотрудник, тяготеющий к внешней референции, охотно воспринимает советы со стороны и готов им следовать.

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

Чтобы вы могли убедиться в правоте этого высказывания, расскажу историю, которой со мной поделилась одна из участниц моего тренинга по управлению коммерческим отделом. Итак, после совместного визита с одной торговой представительницей (причем визит был вполне удачным) руководитель, начиная анализ визита, задает сотруднице вопрос: «Что, на твой взгляд, было удачно, а что можно было бы сделать лучше?» На этот вполне невинный вопрос последовала такая реакция: «Ты же руководитель, не мучай меня, скажи сама, как оцениваешь мой визит». Поведение довольно типичное для людей с внешней референций.

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

Как известно, человека, склонного к внутренней референции, гораздо легче убедить, чем заставить. Эти люди более охотно и ответственно следуют тем выводам, к которым они пришли сами или по крайней мере им кажется, что они к ним пришли. Навязанное мнение или система действий может вызвать протест, который приведет либо к открытому сопротивлению, либо к тихому саботажу, либо к демотивации и снижению лояльности. Расскажу вам случай, который очень хорошо иллюстрирует эту мысль. Несколько лет назад я проводила тренинг по технике продаж в одной компании, где для подразделения, занимающегося продажами, были разработаны стандарты взаимодействия с клиентами (подробное описание того, как именно вести себя с клиентом, включая обязательные и запрещенные фразы). В частности, в них запрещалось задавать клиенту вопрос: «На какую сумму вы рассчитываете?» Еще до тренинга меня предупредили, что это правило очень часто нарушается.

Надо сказать, что в силу технической специфики продукта среди сотрудников подразделения было много людей, тяготеющих к внутренней референции. И вот в ходе тренинга я привожу это правило и спрашиваю: «Можем ли мы предложить клиенту товар на сумму, значительно большую, чем та, которую он назвал в ответ на наш вопрос?» – «Нет» – «Встречаются ли люди, для которых сумма покупки не является определяющей?» – «Да» – «Приходят ли к вам клиенты с небольшими суммами денег, которых такой вопрос может обидеть?» – «Да». И вдруг один из участников говорит с удивлением: «Ребята, оказывается, нам не зря запрещали задавать этот вопрос!» Думаю, комментарии излишни.

Итак, если сотрудник тяготеет к внешней референции, мы можем однозначно остановиться на варианте «мотивация к изменениям + наставничество». Совместный или самостоятельный поиск решения в этой ситуации отнимет много времени и не имеет особого смысла, так как человек изначально настроен на приятие советов и одобрения. Исключением может стать ситуация, в которой за счет постоянного воздействия вы хотите переместить сотрудника в сторону смешанной или внутренней референции. Но такой переход занимает много времени (месяцы, а то и годы) и потребует терпения и больших временны?х затрат со стороны руководителя.

Для сотрудника со смешанной (средний вариант) или внутренней референцией больше подойдут два оставшихся варианта – «мотивация к изменениям + совместный или самостоятельный поиск решений».

Данный текст является ознакомительным фрагментом.

Документация JDK 20 — Главная

1. Главная
2. Ява
3. Java SE
4. 20

Обзор

• Прочтите меня
• Примечания к выпуску
• Что нового
• Руководство по миграции
• Загрузить JDK
• Руководство по установке
• Формат строки версии

Инструменты

• Технические характеристики инструментов JDK
• Руководство пользователя JShell
• Руководство по JavaDoc
• Руководство пользователя средства упаковки

Язык и библиотеки

• Обновления языка
• Основные библиотеки
• HTTP-клиент JDK
• Учебники по Java
• Модульный JDK
• Руководство программиста API бортового регистратора
• Руководство по интернационализации

Технические характеристики

• Документация API
• Язык и ВМ
• Имена стандартных алгоритмов безопасности Java
• банок
• Собственный интерфейс Java (JNI)
• Инструментальный интерфейс JVM (JVM TI)
• Сериализация
• Проводной протокол отладки Java (JDWP)
• Спецификация комментариев к документации для стандартного доклета
• Прочие характеристики

Безопасность

• Руководство по безопасному кодированию
• Руководство по безопасности

Виртуальная машина HotSpot

• Руководство по виртуальной машине Java
• Настройка сборки мусора

Управление и устранение неполадок

• Руководство по устранению неполадок
• Руководство по мониторингу и управлению
• Руководство по JMX

Client Technologies

• Руководство по специальным возможностям Java

Типы значений против ссылочных типов и когда их использовать

В Swift есть две категории типов: типов значений и ссылочных типов . Экземпляр типа значения хранит уникальную копию своих данных, например, структуру или перечисление . эталонный тип , использует одну копию своих данных, и обычно это класс .

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

В этом руководстве вы будете использовать Xcode 10.1 и Swift 4.2.

• Типы значений
• Ссылочные типы
• Изменяемость
• Смешанные типы
• Указатели
• Сводка

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

Типы значений

и ссылочные типы

Типы значений

Экземпляр типа значения является независимым экземпляром и хранит свои данные в своем собственном распределении памяти. Существует несколько различных типов значений : struct , enum и tuple .

Struct

Давайте поэкспериментируем с структур и докажите, что они являются типами значений :

Добавьте следующий код на вашу игровую площадку:

 // 1
структура автомобиля {
    пусть марка: Строка
    переменная модель: строка
}
// 2
var golf = Автомобиль (марка: «Фольксваген», модель: «Гольф»)
// 3
пусть поло = гольф
// 4
golf.model = "Гольф 2019"
// 5
печать(гольф)
принт(поло)
 

В приведенном выше коде вы:

1. Создайте структуру Car со свойствами brand и model .
2. Создайте новый экземпляр Car с именем golf .
3. Создайте копию экземпляра golf с именем polo .
4. Изменить переменную golf.model на Golf 2019
5. Распечатайте 2 разных экземпляра. Первая распечатка выписка распечаток Автомобиль(марка: "Фольксваген", модель: "Гольф 2019") в Консоли. Второй печатает Автомобиль(марка: «Фольксваген», модель: «Гольф») . Даже если polo является копией golf , экземпляры остаются независимыми со своими уникальными копиями данных.

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

Enum

Чтобы проверить, что перечислений являются типами значений , добавьте этот код на игровую площадку:

 // 1
перечисление Язык {
    чехол итальянский
    случай английский
}
// 2
var итальянский = Language.italian
// 3
пусть английский = итальянский
// 4
итальянский = .английский
// 5
печать (итал.)
печать (англ.)
 

В приведенном выше коде вы:

1. Создайте перечисление Language с итальянскими и английскими случаями.
2. Создайте новый экземпляр Language для итальянского языка .
3. Создайте копию экземпляра italian с именем english .
4. Замените экземпляр итальянский на английский .
5. Распечатайте два разных экземпляра. Первый отпечаток 9Оператор 0126 печатает английский , а второй печатает итальянский . Даже если английский является копией итальянский , экземпляры остаются независимыми.

Кортеж

Последний тип значения , который мы рассмотрим, — кортеж . Тип кортежа — это разделенный запятыми список из нуля или более типов, заключенный в круглые скобки. Вы можете получить доступ к его значениям, используя нотацию с точкой ( . ), за которой следует индекс значения.

Вы также можете назвать элементы в кортеже и использовать имена для доступа к различным значениям.

Добавьте на игровую площадку следующий код:

 // 1
var ironMan = ("Тони", "Старк")
// 2
пусть родитель = IronMan
// 3
ironMan.0 = "Альфред"
// 4
печать (железный человек)
печать (родительский)
 

В приведенном выше коде вы:

1. Создайте кортеж ironMan со строками Tony и Stark .
2. Создать копию ironMan 9Экземпляр 0126 с именем родительский .
3. Измените индекс ironMan.0 на Alfred .
4. Распечатайте 2 разных экземпляра. Первый печатает , печатает («Альфред», «Старк») , а второй печатает («Тони», «Старк») . Опять же, экземпляры остаются независимыми.

Теперь вы можете быть уверены, что структур , перечислений и кортежей являются типами значений !

Источник: Marvel Entertainment

Когда использовать типы значений

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

Используйте тип значения , если вы хотите, чтобы копии имели независимое состояние, и данные будут использоваться в коде в нескольких потоках.

В Swift Array , String и Dictionary являются типами значений.

Ссылочные типы

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

Чтобы изучить их, добавьте новую функцию на свою игровую площадку:

 func address(of object: T) -> Int {
    вернуть unsafeBitCast (объект, в: Int. self)
}
 

Эта функция печатает адрес объекта, что поможет вам проверить, ссылаетесь ли вы на один и тот же экземпляр или нет.

Класс

Первый ссылочный тип , который вы увидите, — это класс .

Добавьте следующий код на свою игровую площадку:

 // 1
класс Собака: CustomStringConvertible {
    переменный возраст: Int
    вес переменной: Int
    // 2
    Описание переменной: Строка {
        return "Возраст\(возраст) - Вес\(вес)"
    }
    // 3
    инициализация (возраст: Int, вес: Int) {
        возраст = возраст
        собственный вес = вес
    }
}
// 4
пусть доберман = собака (возраст: 1, вес: 70)
// 5
пусть чихуахуа = доберман
// 6
доберман.возраст = 2
// 7
чихуахуа.вес = 10
// 8
печать (доберман)
печать (чихуахуа)
// 9распечатать (адрес (из: добермана))
печать (адрес (из: чихуахуа))
 

В приведенном выше коде необходимо:

1. Создать новый класс с именем Dog , который соответствует CustomStringConvertible для печати пользовательских описаний объекта.
2. Определите пользовательское описание объекта.
3. Создайте новую функцию init . Это необходимо, потому что, в отличие от структуры , класс не создает автоматически функцию инициализации на основе переменных объекта.
4. Создайте экземпляр doberman Dog .
5. Создайте копию добермана с именем чихуахуа .
6. Заменить doberman.age на 2 .
7. Заменить чихуахуа.вес на 10 .
8. Распечатайте описание двух разных экземпляров. Первый печатает , печатает Возраст 2 - Вес 10 , второй печатает то же самое; Возраст 2 - Вес 10 . Это потому, что вы на самом деле ссылаетесь на один и тот же объект.
9. Вывести адреса двух разных экземпляров. С этими отпечатками вы будете уверены, что ссылаетесь на один и тот же адрес. Вы увидите, что оба оператора print выводят одно и то же значение.

Вы можете быть уверены, что класс является ссылочным типом .

Функции и замыкания

Замыкание используется для ссылки на функцию вместе с переменными из ее области, которую она инкапсулирует. Функции — это, по сути, замыкания, которые хранят ссылки на переменные в своем контексте.

Взгляните на код ниже:

 let closure = { print("Test") }
func function () -> () { print («Тест») }
закрытие()
функция()
 

Они оба делают одно и то же.

Дополнительную информацию о замыканиях можно найти в документации Swift.

Когда использовать ссылочные типы

Использование ссылочного типа при сравнении идентификатора экземпляра с === имеет смысл. === проверяет, имеют ли два объекта один и тот же адрес памяти.

Они также полезны, когда вы хотите создать общее изменяемое состояние.

Как правило, начните с создания экземпляра в виде перечисления , затем перейдите к структуре , если вам нужна дополнительная настройка, и, наконец, при необходимости перейдите к классу .

Изменяемость

Изменяемость типов значений позволяет конкретно выбирать, какие переменные можно изменять, а какие нет.

Добавьте этот код на свою игровую площадку:

 // 1
структура велосипеда {
    // 2
    пусть радиус: Int
    вар км: Плавающая
}
// 3
пусть велосипед = велосипед (радиус: 22, км: 34,5)
 

В этом коде вы:

1. Создайте велосипед структуру .
2. Создайте свойство let и свойство var .
3. Создайте константу Bike . Даже если km внутри Bike struct является var , вы не можете редактировать это, потому что bike является let .

Если вы создадите константу struct , вы не сможете изменить значения ее свойств, даже если сами значения могут быть переменными.

Класс , с другой стороны, позволяет вам изменять их, потому что вы ссылаетесь на адрес памяти объекта.

Добавьте следующий код:

 // 1
класс Мотоцикл {
    // 2
    пусть радиус: Int
    вар км: Плавающая
    init(радиус: Int, км: Float) {
        self.radius = радиус
        сел.км = км
    }
}
// 3
пусть мотоцикл = мотоцикл (радиус: 22, км: 34,5)
мотоцикл.км += 1
// 4
печать(мотоцикл.км)
 

В коде выше вы будете:

1. Создать мотоцикл класса .
2. Создать радиус как пусть и км как var .
3. Добавьте 1 к переменной motorbike.km .
4. Выведите переменную motorbike.km .

Вы можете установить переменную км , потому что Мотоцикл — это класс, и мы ссылаемся на его адрес в памяти.

Источник: Warner Bros. Pictures

Неизменяемое ключевое слово

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

Снова добавьте этот код на игровую площадку:

 // 1
Фонд импорта
// 2
struct Cat: CustomStringConvertible {
    // 3
    имя переменной: строка? {
        // 4
        получать {
            вернуть UserDefaults.standard.string(forKey: "CatName")
        }
        // 5
        немутирующий набор {
            если позволить новое значение = новое значение {
                UserDefaults.standard.set(newValue, forKey: "CatName")
            } еще {
                UserDefaults.standard.removeObject(forKey: "CatName")
            }
        }
    }
    Описание переменной: Строка {
        вернуть имя ?? ""
    }
}
// 6
пусть кошка = кошка ()
cat.name = "Сэм"
// 7
пусть тигр = кошка ()
Tiger.name = "Олли"
 

В приведенном выше коде вы:

1. Импортируете Foundation , потому что игровые площадки не делают этого по умолчанию.
2. Создайте структуру Cat .
3. Создайте переменную name .
4. Укажите, как получить имя Cat , обратившись к UserDefaults .
5. Укажите поведение без изменений set для установки нового имени в UserDefaults если не nil , в противном случае удалите его.
6. Создайте новый экземпляр Cat с именем cat и задайте для его имя значение «Sam».
7. Создайте новый экземпляр Cat с именем tiger и задайте для его имени значение «Olly».

Итак, что здесь происходит? У обеих кошек есть имя «Олли», потому что они используют UserDefaults , чтобы получить свое имя. Кроме того, даже если обе константы, вы можете установить их name свойство без каких-либо предупреждений или ошибок.

Смешанные типы

Что произойдет, если смешать типов значений с ссылочными типами и наоборот?

Вы часто можете столкнуться с осложнениями, смешивая эти типы вместе. Давайте рассмотрим несколько примеров, чтобы вы могли избежать этих распространенных ошибок.

Смешивание типов значений в ссылочных типах

Давайте начнем со смешивания типов значений в ссылочных типах , добавив struct внутри класса и посмотрите, что произойдет.

Допустим, у вас есть производитель, выпускающий какое-то устройство. Вы создадите класс Устройство и структуру Производитель .

Добавьте на игровую площадку следующий код:

 // 1
структура Производитель {
    имя переменной: строка
}
// 2
класс устройства {
    имя переменной: строка
    // 3
    вар производитель: Производитель
    инициализация (имя: строка, производитель: производитель) {
        self.name = имя
        self.manufacturer = производитель
    }
}
// 4
пусть яблоко = Производитель (имя: «Apple»)
// 5
пусть iPhone = устройство (имя: «iPhone», производитель: яблоко)
пусть iPad = устройство (название: «iPad», производитель: яблоко)
// 6
iPad. manufacturer.name = "Google"
// 7
печать(iPhone.производитель.название)
print(iPad.производитель.название)
 

В приведенном выше коде вы:

1. Создайте структуру Производитель со свойством имени.
2. Создайте класс Device с именем и свойствами производителя.
3. Укажите производителя устройства.
4. Создайте производителя с именем «Apple».
5. Создайте два устройства: «iPhone» и «iPad».
6. Apple продала подразделение iPad компании Google.
7. Печать двух названий производителей.

Вы увидите, что два устройства теперь имеют разных производителей. Производитель iPhone — Apple, а производитель iPad — Google.

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

Смешивание ссылочных типов в типах значений

Теперь мы рассмотрим, что происходит, когда вы смешиваете ссылочных типов внутри типов значений .

На этот раз у вас будет два самолета и один двигатель. Вы определите Структура самолета и двигатель класса . Конечно, у самолета есть двигатель.

Добавьте следующий код:

 // 1
Класс Engine: CustomStringConvertible {
    Описание переменной: Строка {
        вернуть "\(тип) Engine"
    }
    тип переменной: строка
    инициализация (тип: строка) {
        self.type = тип
    }
}
// 2
структура Самолет {
    вар двигателя: Двигатель
}
// 3
пусть jetEngine = Двигатель (тип: "Реактивный")
// 4
пусть bigAirplane = Самолет (двигатель: jetEngine)
let littleAirplane = Самолет (двигатель: jetEngine)
// 5
littleAirplane.engine.type = "Ракета"
// 6
печать (большой самолет)
печать (маленький самолет)
 

В приведенном выше коде вы:

1. Создайте класс Engine с его типом .
2. Создайте структуру Самолет с двигателем .
3. Создать реактивный двигатель.
4. Создайте два самолета с одним и тем же экземпляром Engine .
5. Заменить двигатель littleAirplane на «Ракетный».
6. Распечатайте два объекта самолета.

Как видите, оба самолета имеют один и тот же двигатель, ракетный двигатель. Это потому, что вы ссылаетесь на одни и те же Двигатель экземпляр. Даже если вы создали два экземпляра Airplane с одним и тем же Engine , они не будут копировать ссылочный тип , как типов значений .

Источник: Marvel Entertainment

Указатели

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

Добавьте следующий код:

 // 1
func addKm(to bike: inout Bike, km: Float) {
    велосипед. км += км
}
// 2
var awesomeBike = Велосипед (радиус: 22, км: 20)
// 3
добавить км (к: &awesomeBike, км: 10)
// 4
печать (крутой велосипед)
 

В приведенном выше коде необходимо:

1. Создать функцию addKm , которая принимает параметр inout Bike .
2. Создайте новый экземпляр Bike с именем awesomeBike .
3. Позвоните в addKm с оператором и . Оператор и указывает функции передать адрес переменной вместо ее копии.
4. Распечатайте экземпляр awesomeBike .

Вы увидите, что, напечатав переменную awesomeBike , ее км будет 30 , потому что вы не создаете ее копию. Вместо этого вы используете тот же экземпляр.

Ссылочные типы работают таким же образом. Вы можете пройти их с inout или нет, а результат будет тот же.

Добавьте этот код на игровую площадку:

 func addKm (к мотоциклу: inout Мотоцикл, км: Float) {
    мотоцикл. км += км
}
var awesomeMotorbike = Мотоцикл (радиус: 30, км: 25)
добавить км (к: &awesomeMotorbike, км: 15)
печать (крутой мотоцикл.км)
 

Как и раньше, вы создали новый экземпляр Мотоцикл , назвали мотоцикл и передали его функции addKm . Окончательный отпечаток напечатает 40 км.

Теперь добавьте следующий код:

 func addKm(к мотоциклу: мотоцикл, км: плавающий) {
    мотоцикл.км += км
}
добавить км (к: awesomeMotorbike, км: 15)
печать (крутой мотоцикл.км)
 

Результаты те же. Ваш последний экземпляр мотоцикла теперь имеет 55 км.

Резюме

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

Вы можете скачать финальную площадку для этого поста здесь.

Одним из больших преимуществ использования типов значений Swift по умолчанию , таких как Массив , является функция Копировать при записи .