Главная - Литература

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 [78] 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294

10.4. Область видимости

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

В разных языках реализованы разные подходы к области видимости. В некоторых примитивных языках все переменные глобальны. В этом случае вы не имеете контроля над областью видимости переменных, что создает много проблем. В С++ и похожих языках переменная может иметь область видимости, соответствующую блоку (фрагменту кода, заключенному в фигурные скобки), методу, классу (возможно, и производным от него классам) или всей программе. В Java и С* переменная может также иметь область видимости, соответствующую пакету или пространству имен (набору классов).

Ниже я привел ряд советов, относящихся к области видимости.

Локализуйте обращения к переменным

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

Идея локализации обращений к переменным самоочевидна, однако она допускает и формальную оценку. Одним из методов оценки степени сгруппированности обращений к переменной является определение «интервала» (span) между обращениями, например:

Пример определения интервалов между обращениями к переменным (Java)

а = 0; b = 0; с = 0; а = b + с;

В данном случае между первым и вторым обращениями к а находятся две строки кода, поэтому и интервал равен 2. Между двумя обращениями к - одна строка, что дает нам интервал, равный 1, ну а интервал между обращениями к с равен 0. Вот еще один пример:



Пример интервалов, равных 1 и О (Java)

а = 0; b = 0; с = 0; b = а + 1; b = b / с;

В этом примере между первым и вторым обращениями кЬ - дццшценые ееецши 06 одна строка кода, а между вторым и третьим обращениями интервалах нежду обращения-строк нет, поэтому интервалы равны соответственно 1 и 0. ми к переменным см. работу Средний интервал вычисляется путем усреднения отдельных flf , Щтвпщ Шпсв интервалов. Так, во втором примере средний интервал между 1 обращениями к b равен (1+0)/2, или 0,5. Локализовав обращения к переменным, вы позволите программисту, который будет читать ваш код, сосредоточиваться на меньшем фрагменте программы в каждый конкретный момент времени. Если обращения будут распределены по большему фрагменту кода, уследить за ними будет сложнее. Таким образом, главное преимущество локализации обращений к переменным в том, что оно облегчает чтение программы.

Делайте время жизни переменных как можно короче

С интервалом между обращениями к переменной тесно связано «время жизни» переменной - общее число строк, на протяжении которых переменная используется. Жизнь переменной начинается при первом обращении к ней, а заканчивается при последнем.

В отличие от интервала время жизни переменной не зависит от числа обращений к ней между первым и последним обращениями. Если переменная в первый раз вызывается в строке 1, а в последний - в строке 25, ее время жизни равно 25 строкам. Если переменная используется только в этих двух строках, средний интервал между обращениями к ней - 23 строки. Если бы между строками 1 и 25 переменная вызывалась в каждой строке, она имела бы средний интервал, равный О, но время ее жизни по-прежнему равнялось бы 25 строкам. Связь интервалов между обращениями к переменной и времени ее жизни пояснена на рис. 10-1.

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

Второе преимущество короткого срока жизни: оно позволяет получить верное представление о коде. Если переменная изменяется в строке 10 и вызывается в строке 45, само пространство между двумя обращениями подразумевает, что переменная используется также между строками 10 и 45. Если переменная изменяется в строке 44 и вызывается в строке 45, других обращений к ней между этими строками быть не может, что позволяет вам сосредоточиться на меньшем фрагменте кода.




Длительное время а жизни я


"2

Короткое время жизни

Небольшие интервалы

Рис, 10-1. «Длительное время жизни» подразумевает, что переменная используется в крупном фрагменте кода. При «коротком времени жизни» переменная используется лишь в небольшом фрагменте. «Интервал между обращениями» к переменной характеризует, насколько тесно сгруппированы обращения к переменной

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

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

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

Оценка времени жизни переменной

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

Пример слишком долгого времени жизни переменных (Java)

1 инициализация каждой переменной

2 recordlndex = 0;

3 total = 0;

6872



0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 [78] 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294



0.0138