Когда использовать сам на свойствах класса?
Если цель состоит в том, чтобы добавить заголовок авторизации при сохранении существующих заголовков, в этом случае content-type, вы можете использовать request.headers.set() вместо setHeaders(), поскольку setHeaders() полностью заменяет заголовки:
import { Injectable } from "@angular/core";
import {
HttpRequest,
HttpHandler,
HttpEvent,
HttpInterceptor
} from "@angular/common/http";
import { Observable } from "rxjs";
@Injectable()
export class JwtInterceptor implements HttpInterceptor {
intercept(
request: HttpRequest<any>,
next: HttpHandler
): Observable<HttpEvent<any>> {
// add authorization header with jwt token if available
let credentials = JSON.parse(localStorage.getItem("credentials"));
console.log(JSON.stringify(credentials.accessToken));
if (credentials && credentials.accessToken) {
request = request.clone({
headers: request.headers.set('Authorization', `Bearer ${credentials.accessToken}`)
});
}
return next.handle(request);
}
}
Надеюсь, это поможет!
8 ответов
Да, есть разница как в памяти, так и в производительности.
MyProperty = @"hi there";
Это считается прямым назначением. Практически нет влияния на память или производительность. Конечно, нельзя сказать, что это лучшая практика - это другой вопрос: )
@property(nonatomic, copy) NSString *MyProperty;
// ...
self.MyProperty = @"hi there";
Этот оператор существенно влияет на память и производительность. По сути, это эквивалентно:
-(void)setMyProperty(NSString *)newValue {
if (MyProperty != newValue) {
[MyProperty release];
MyProperty = [newValue copy];
}
}
Старое значение освобождается, а новое значение копируется в MyProperty. Это приемлемо и особенно типично при работе со строками, когда строка, которую вы присваиваете, является изменяемой (т.е. она может измениться позже).
Если, как в вашем примере, вы просто присваиваете статическую строку (@ "hi there" ), нет ничего плохого в прямом присвоении строкового значения; он более эффективен, однако разница в производительности незначительна.
Вы можете объявить свойство с помощью @property как сохранить, скопировать или присвоить (по умолчанию - assign). Затем вы можете сгенерировать методы «доступа» (геттер / сеттер) с помощью @synthesize. Вот как выглядят сеттеры, которые генерируются, когда вы это делаете:
// @property(nonatomic, assign)
-(void)setMyProperty(NSString *)newValue {
MyProperty = newValue;
}
// @property(nonatomic, retain)
-(void)setMyProperty(NSString *)newValue {
if (property != newValue) {
[property release];
property = [newValue retain];
}
// @property(nonatomic, copy)
-(void)setMyProperty(NSString *)newValue {
if (property != newValue) {
[property release];
property = [newValue copy];
}
}
Дополнительная информация о Объявленных свойствах ObjectiveC .
«Вы можете использовать директивы @synthesize и @dynamic в блоках @implementation для запуска определенных действий компилятора. Обратите внимание, что ни то, ни другое не требуется для любого заданного @property
Важно: если вы не укажете ни @synthesize, ни @dynamic для определенного свойства, вы должны предоставить для этого свойства реализацию метода получения и установки (или просто метода получения в случае свойства только для чтения) ».
Другими словами, если вы объявляете свойство, но не синтезируете его, вы не сможете использовать [self MyProperty] или self.MyProperty, если не определите методы MyProperty и setMyProperty. Если вы не объявляете свойство, тогда у вас просто есть переменная экземпляра.
Примечание: @dynamic не делает ' t сгенерировать аксессоры. Он действительно используется, если вы динамически (т. Е. Магическим образом) разрешаете методы доступа через загрузку кода или разрешение динамического метода.
Разница в том, что
self.MyProperty = @"hi there"
- это вызов с точечной нотацией, который вызывает сгенерированный метод доступа, который будет правильно обрабатывать счетчики удержаний (эквивалент [self setMyProperty: @ "привет там"]) , тогда как
MyProperty = @"hi there"
- это прямое присвоение вашей переменной-члену, которое не освобождает старое значение, не сохраняет новое и не делает ничего другого, что делает ваш метод доступа (например, если у вас есть настраиваемый установщик, который выполняет дополнительную работу).
Так что да, между ними есть большая разница в управлении памятью и в поведении в целом. Последняя форма почти всегда неверна, если вы не знаете конкретно, почему вы это делаете, и что вы сами правильно обрабатываете счетчик удержания.
Если вы используете автоматическое наблюдение за значением ключа (или любую основанную на нем технологию Какао - например, привязки, ...), также важно использовать установщик. Наблюдатель не получит никаких уведомлений, если вы назначите ivar. Если вы привяжете «MyProperty» к полю NSText и измените свой ivar «MyProperty» с помощью кода, связанное текстовое поле все равно будет отображать старое значение, поскольку оно не получило никаких уведомлений об изменении.
For the second part of the question, property definition is not needed, it is a help to us . The @synthesize directive on property generates accessor methods for properties so we don't have to do it manually, and because:
This code instructs the compiler to generate, or synthesize, the accessor methods. The compiler will generate the accessor methods using well-tested, fast algorithms that are ready for multi-core and multi-threaded environments, including locking variables in setter methods. Not only does using properties reduce the amount of code that you have to write, it replaces that code with the best possible accessors for today's modern multi-core systems. Later, if you need to provide an alternative implementation for a property accessor, you can simply add the appropriate code to your class.
http://developer.apple.com/leopard/overview/objectivec2.html
The nonatomic will avoid use of locking when accessing variables, if you don't specify anything then default is atomic. Locking is useful on multithreaded systems. The copy specifies what code should be generated for accessors, copy will copy the object, retain will retain new object and release old one, assign is good for simple variables like int to just plain assign values.
So when you define your property as you did above (nonatomic,copy) and then use self.MyProperty = @"Hey" you're actually calling generated accessor that will make a copy of the new variable as opposed to just assigning it. You can override accessor and add checking to it.
Because of the above I would say that defining property has benefits even when the variable is not used outside of the class.
I believe to access properties you should use self.MyProperty instead of just MyProperty but I can't point you to explanation why.
Might be something to do with the fact that compiler will generate from
self.MyProperty = @"Hey";
this:
[self setMyProperty: @"Hey"];
But I'm only speculating here.
Whether you call self.MyProperty or MyProperty it should not affect memory management (I would still prefer the first - self.MyProperty).
See Objective-C 2.0 Overview for some high level description from Apple.
В качестве дополнения к другим ответам попробуйте думать об этом так:
self.MyProperty = @"hi there";
или
[self setMyProperty:@"hi there"];
(что эквивалентно) оба вызывают метод, тогда как
MyProperty = @"hi there";
просто устанавливает переменную.
По-прежнему не ясно, когда использовать аксессоры, а когда выполнять прямое назначение для ivars? Я видел много примеров Apple, которые напрямую обращаются к ivars. Так что использование свойств для всех ivars кажется педантичным излишеством.
Похоже, что только важные ивары, которые должны быть дольше и доступны извне, как правило, используют эти свойства.
Был бы признателен некоторым гуру Какао, чтобы вмешаться и уточнить.
Чтобы получить доступ к переменной, часто нет необходимости использовать точечную нотацию. Таким образом, в коде, сгенерированном шаблонами XCode, вы увидите такие вещи, как:
[flipsideViewController viewWillAppear:YES];
Здесь нет необходимости писать self.flipsideViewController, потому что метод доступа обычно ничего не делает, кроме передачи вам переменной.
Так что хорошее правило Практический опыт заключается в том, чтобы использовать точечную нотацию, когда вы устанавливаете переменную (абсолютно необходимо, если вы не хотите самостоятельно сохранять и освобождать), но не когда вы обращаетесь к ей:
self.aString = @"Text text text";
NSLog (aString); // No need for self.aString here
NSString* tmpString = aString; // Here neither
Когда вы используете не-объектные типы, такие как int или float или многие другие, вы можете избежать использования точечной нотации / метода установки. В этих случаях сохранять нечего, поэтому метод установки мало что дает, кроме простого присвоения значения.
Однако , синтезированные геттеры и сеттеры делают больше, чем просто сохраняют и освобождают. Как уже упоминали другие, они также являются двигателем, который поддерживает работу системы KVO. Таким образом, вам следует использовать подходящие сеттеры даже для целых чисел, чисел с плавающей запятой и т. Д.
А как насчет аксессоров? В более сложных контекстах класс может ответить на запрос значения переменной , даже если переменная не существует . Процитируя возвышенное руководство по Objective-C, классы могут предоставлять «реализации методов напрямую или во время выполнения с использованием других механизмов [кроме простых методов доступа], таких как динамическая загрузка кода или разрешение динамических методов».
(Один из способов реализации такого рода оперативного ответа на сообщения путем переопределения методов NSObject, таких как methodSignatureForSelector: и forwardInvocation:.)
По этой причине использование правильно объявленных интерфейсов (синтезированных или нет) - всегда хорошая идея, когда вы работаете над чем-то большим. Но вполне нормально получить доступ к ivar напрямую, если вы установили их, используя правильный API.
(Примечание: я не гуру Cocoa, поэтому исправления более чем приветствуются.)
Это старый вопрос, хотя раньше он был таким: «Когда мне писать [self setMyProperty: @" привет "] ?" (Обратите внимание, что self.MyProperty = @ "hi there" в точности эквивалентно этому.)
Ответ, который я всегда слышал (и который имеет смысл): всегда использовать аксессуар; никогда пишите MyProperty = @ "привет" . Есть несколько причин:
- Управление памятью делается за вас; вам не нужно беспокоиться о правильном сохранении / выпуске / копировании.
- В будущем проще изменить ваш код; если в какой-то момент вы поймете, что изменение
MyPropertyдолжно иметь определенный побочный эффект,