У меня есть эта функция в классе:
func multiply(factor1:Int, factor2:Int) -> Int{
return factor1 * factor2
}
Я пытаюсь вызвать функцию, используя это:
var multResult = calculator.multiply(9834, 2321)
Проблема в том, что компилятор хочет, чтобы он выглядел примерно так:
var multResult = calculator.multiply(9834, factor2: 2321)
Почему первый вызывает ошибку?
Обновление для Swift 2.0: теперь функции по умолчанию ведут себя идентично методам, причем для обоих:
В остальном правила ниже по-прежнему применяются, за исключением того, что сокращенный синтаксис # больше не используется.
Вот более общий ответ: функции ведут себя по-разному, когда они определены как истинные функции вне класса, и когда они определены как методы. Более того, у методов инициализации есть особое правило.
Предположим, вы определили это:
func multiply1(f1: Double, f2: Double) -> Double {
return f1 * f2
}
Имена параметров здесь только локальны для функции и не могут использоваться при вызове функции:
multiply1(10.0, 10.0)
Если вы хотите принудительно использовать именованные параметры при вызове функции, вы можете. Перед каждым объявлением параметра укажите его внешнее имя. Здесь внешнее имя f1 - f1param, а для f2 мы используем сокращение, в котором мы префикс #, чтобы указать, что локальное имя также должно использоваться как внешнее имя:
func multiply2(f1param f1: Double, #f2: Double) -> Double {
return f1 * f2
}
Затем необходимо использовать именованные параметры:
multiply2(f1param: 10.0, f2: 10.0)
С методами дело обстоит иначе. По умолчанию, как вы обнаружили, все параметры, кроме первого, имеют имена. Предположим, у нас есть это, и рассмотрим метод multiply1:
class Calc {
func multiply1(f1: Double, f2: Double) -> Double {
return f1 * f2
}
func multiply2(f1param f1: Double, f2: Double) -> Double {
return f1 * f2
}
func multiply3(f1: Double, _ f2: Double) -> Double {
return f1 * f2
}
}
Затем вы должны использовать имя второго (и следующих, если есть) параметров:
let calc = Calc()
calc.multiply1(1.0, f2: 10.0)
Вы можете принудительно использовать именованный параметр для первого аргумента, указав для него внешнее имя, например для функций (или добавив к его локальному имени префикс #, если вы хотите использовать то же внешнее имя, что и его локальное имя). Затем вы должны использовать его:
calc.multiply2(f1param: 10.0, f2: 10.0)
Наконец, вы можете объявить внешнее имя _ для других следующих аргументов, указывая, что вы хотите вызвать свой метод без использования именованных параметров, например:
calc.multiply3(10.0, 10.0)
Примечание о совместимости: если вы поставите перед class Calc аннотацию @objc, вы сможете использовать ее из кода Objective-C, и это эквивалентно этому объявлению (посмотрите на имена параметров):
@interface Calc
- (double)multiply1:(double)f1 f2:(double)f2;
- (double)multiply2WithF1param:(double)f1 f2:(double)f2;
- (double)multiply3:(double)f1 :(double)f2;
@end
Правило немного отличается для init методов, где все параметры по умолчанию имеют внешнее имя. Например, это работает:
class Calc {
init(start: Int) {}
init(_ start: String) {}
}
let c1 = Calc(start: 6)
let c2 = Calc("6")
Здесь вы должны указать start: для перегрузки, которая принимает Int, но вы должны опустить его для перегрузки, которая принимает String.
Примечание о совместимости: этот класс будет экспортирован в Objective-C следующим образом:
@interface Calc
- (instancetype)initWithStart:(NSInteger)start __attribute__((objc_designated_initializer));
- (instancetype)init:(NSString *)start __attribute__((objc_designated_initializer));
@end
Предположим, вы определяете тип закрытия следующим образом:
typealias FancyFunction = (f1: Double, f2: Double) -> Double
Имена параметров будут вести себя очень похоже на имена в методе. Вам нужно будет указать имена для параметров при вызове закрытия, если вы явно не установите для внешнего имени значение _.
Например, выполнение закрытия:
fund doSomethingInteresting(withFunction: FancyFunction) {
withFunction(f1: 1.0, f2: 3.0)
}
Практическое правило: даже если они вам не нравятся, вам, вероятно, следует попытаться продолжать использовать именованные параметры, по крайней мере, всякий раз, когда два параметра имеют один и тот же тип, чтобы устранить их неоднозначность. Я бы также сказал, что хорошо также указать хотя бы все параметры Int и Boolean.
init методов.
- person Jean-Philippe Pellet; 10.06.2014
'#' has been removed from Swift; double up 'param param' to make the argument label the same as the parameter name
- person Kof; 29.11.2015
typealias, я получаю ошибку компилятора. Это изменилось?
- person dcow; 03.04.2018
Имена параметров в вызове функции называются именами ключевых слов, и их корни восходят к языку Smalltalk.
Классы и объекты часто повторно используются откуда-то еще или составляют часть очень больших сложных систем и не будут привлекать к себе активного внимания обслуживания в течение длительного времени.
Повышение ясности и разборчивости кода очень важно в таких ситуациях, поскольку код часто оказывается единственной документацией, когда разработчики находятся под давлением крайних сроков.
Присвоение каждому параметру описательного имени ключевого слова позволяет специалистам по сопровождению быстро увидеть, какова цель вызова функции, взглянув на вызов функции, а не углубляться в сам код функции. Это делает явным подразумеваемое значение параметров.
Последним языком, на котором используются имена ключевых слов для параметров в вызовах функций, является Rust (ссылка), описываемый как "a язык системного программирования, который работает невероятно быстро, предотвращает сбои и гарантирует безопасность потоков ».
Системы с высоким временем безотказной работы требуют более высокого качества кода. Имена ключевых слов предоставляют группам разработки и сопровождения гораздо больше возможностей избегать и отлавливания ошибок, связанных с отправкой неправильного параметра или неправильным вызовом параметров.
Они могут быть многословными или краткими, но Smalltalkers предпочитают многословность и описательность кратким и бессмысленным. Они могут себе это позволить, потому что их IDE сделает за них основную часть набора текста.
поскольку вы использовали calculator.multiply() в примере кода, я предполагаю, что эта функция является методом объекта calculator.
Swift наследует множество вещей от objective-c, и вот один из них:
Когда в объекте-c вы бы сделали (гипотетически):
[calculator multiply:@9834 factor2:@2321];
calculator.multiply(9834, factor2:2321);
Поскольку ваша функция "умножение" - это метод, и, как и в Objective-c, параметры в методах являются частью имени.
Например, вы можете это сделать.
class Calculator {
func multiply(factor1:Int, factor2:Int) -> Int{
return factor1 * factor2
}
func multiply(factor1:Int, factor2:Int, factor3:Int) -> Int{
return factor1 * factor2 * factor3
}
}
Здесь есть два разных метода с разными названиями: умножение (factor2) и умножение (factor2 factor3).
Это правило применяется только к методам, если вы объявляете это как функции вне класса, тогда для вызова функции не требуется имя параметра.
func multiplyFactor1(factor1: Int, factor2:Int) {} Итак, когда вы вызываете метод, вы пропустили первый параметр, чтобы избежать повторения его имени. myCalculator.multiplyFactor1(2, facto2:2) Читабельнее чем. myCalculator.multiplyFactor1(factor1: 2, facto2:2)
- person Daniel; 29.07.2014
Причина историческая. Так он работал в Smalltalk и сохранился до его потомков. Писк, Scratch, Blockly, Objective C и Swift.
Детские языки (Squeak, Scratch и Blockly) придерживались этого, потому что начинающие программисты, как правило, борются с арностью и порядком параметров. Это была изначальная причина, по которой Smalltalk сделал это именно так. Я не знаю, почему ObjC и Swift решили принять это соглашение, но они это сделали.
Примечание о передаче метода в качестве аргумента, который не возвращает значения:
func refresh(obj:Obj, _ method: (Obj)->Void = setValue) {
method(element)
}
func setValue(obj:Obj){
obj.value = "someValue"
}
refresh(someObj,setValue)
NSObject)? Он отмечен знаком@objc? Если это так, компилятор предполагает, что он может быть вызван из Objective-C, поэтому его методы должны иметь форму, совместимую с соглашениями о вызове / именовании методов Objective-C. - person Ken Thomases schedule 05.06.2014_передfactor2, напримерfunc multiply(factor1:Int, _ factor2:Int) {...}. - person Hlung schedule 18.04.2015func multiply(factor1:Int, factor2:Int)наfunc multiply(factor1:Int, _ factor2:Int). Это НЕ взлом, а синтаксис официального языка. - person Jacob R schedule 03.07.2015