1. struct ngx_http_request_s {
  2. uint32_t signature; /* "HTTP" */
  3.  
  4. //请求对应的客户端连接
  5. ngx_connection_t *connection;
  6.  
  7. //指向存放所有HTTP模块的上下文结构体的指针数组
  8. void **ctx;
  9. //指向请求对应的存放main级别配置结构体的指针数组
  10. void **main_conf;
  11. //指向请求对应的存放srv级别配置结构体的指针数组
  12. void **srv_conf;
  13. //指向请求对应的存放loc级别配置结构体的指针数组
  14. void **loc_conf;
  15.  
  16. /*
  17. * 在接收完http头部,第一次在业务上处理http请求时,http框架提供的处理方法是ngx_http_process_request。
  18. 但如果该方法无法一次处理完该请求的全部业务,在归还控制权到epoll时间模块后,该请求再次被回调时,
  19. 将通过Ngx_http_request_handler方法来处理,而这个方法中对于可读事件的处理就是调用read_event_handler处理请求。
  20. 也就是说,http模块希望在底层处理请求的读事件时,重新实现read_event_handler方法
  21. */
  22. ngx_http_event_handler_pt read_event_handler;
  23. //与上面的方法类似
  24. ngx_http_event_handler_pt write_event_handler;
  25.  
  26. #if (NGX_HTTP_CACHE)
  27. ngx_http_cache_t *cache;
  28. #endif
  29.  
  30. //upstream机制用到的结构体
  31. ngx_http_upstream_t *upstream;
  32. ngx_array_t *upstream_states;
  33. /* of ngx_http_upstream_state_t */
  34.  
  35. //这个请求的内存池
  36. ngx_pool_t *pool;
  37. //用于接收http请求内容的缓冲区,主要接收http头部
  38. ngx_buf_t *header_in;
  39.  
  40. //ngx_http_process_request_headers在接收、解析完http请求的头部后,会把解析完的每一个http头部加入到headers_in的headers链表中,同时会构造headers_in中的其他成员
  41. ngx_http_headers_in_t headers_in;
  42. //http模块会把想要发送的http相应信息放到headers_out中,期望http框架将headers_out中的成员序列化为http响应包发送给用户
  43. ngx_http_headers_out_t headers_out;
  44.  
  45. //接收请求中包体的数据结构
  46. ngx_http_request_body_t *request_body;
  47.  
  48. //延迟关闭连接的时间
  49. time_t lingering_time;
  50. //当前请求初始化时的时间
  51. time_t start_sec;
  52. ngx_msec_t start_msec;
  53.  
  54. //下面的9个成员是函数ngx_http_process_request_line方法在接收、解析http请求行时解析出的信息
  55. ngx_uint_t method;//方法名
  56. ngx_uint_t http_version;//协议版本
  57.  
  58. ngx_str_t request_line;
  59. ngx_str_t uri;//用户请求中的uri
  60. ngx_str_t args;//用户请求中的url参数
  61. ngx_str_t exten;//用户请求的文件扩展名
  62. ngx_str_t unparsed_uri;//没有进行URL解码的原始请求
  63.  
  64. ngx_str_t method_name;//用户请求中的方法名字符串
  65. ngx_str_t http_protocol;//其data成员指向请求中http起始地址
  66.  
  67. /*表示需要发送给客户端的http响应。out中保存着由headers_out中序列化后的表示http头部的TCP流。
  68. * 在调用ngx_http_output_filter方法后,out中还会保存着待发送的http包体,它是实现异步发送http响应的关键。*/
  69. ngx_chain_t *out;
  70. /*当前请求既有可能是用户发来的请求,也可能是派生出的子请求。
  71. * 而main标识一系列相关的派生子请求的原始请求。
  72. * 一般可通过main和当前请求的地址是否相等来判断当前请求是否为用户发来的原始请求。*/
  73. ngx_http_request_t *main;
  74. //当前请求的父请求(不一定是原始请求)
  75. ngx_http_request_t *parent;
  76. //与subrequest子请求相关的功能
  77. ngx_http_postponed_request_t *postponed;
  78. ngx_http_post_subrequest_t *post_subrequest;
  79. //所有的子请求都是通过这个单链表链接起来的
  80. ngx_http_posted_request_t *posted_requests;
  81.  
  82. /*全局的ngx_http_phase_engine_t结构体中定义了一个ngx_http_phase_handler_t回答方法组成的数组。
  83. * 而phase_handler成员则与该数组配合使用。表示请求下次应当执行phase_handler作为序列号指定的数组中的回调方法*/
  84. ngx_int_t phase_handler;
  85. //表示NGX_HTTP_CONTENT_PHASE阶段提供给http模块处理请求的一种方式,它指向http模块实现的请求处理方法
  86. ngx_http_handler_pt content_handler;
  87. //在NGX_HTTP_ACCESS_PHASE节点需要判断请求是否具有访问权限时,通过access_code来传递http模块的handler回调方法的返回值,如果为0表示具备权限。否则不具备。
  88. ngx_uint_t access_code;
  89.  
  90. ngx_http_variable_value_t *variables;
  91.  
  92. #if (NGX_PCRE)
  93. ngx_uint_t ncaptures;
  94. int *captures;
  95. u_char *captures_data;
  96. #endif
  97.  
  98. size_t limit_rate;
  99.  
  100. /* used to learn the Apache compatible response length without a header */
  101. size_t header_size;
  102.  
  103. //http请求的全部长度,包括http包体
  104. off_t request_length;
  105.  
  106. ngx_uint_t err_status;
  107.  
  108. ngx_http_connection_t *http_connection;
  109. #if (NGX_HTTP_SPDY)
  110. ngx_http_spdy_stream_t *spdy_stream;
  111. #endif
  112.  
  113. ngx_http_log_handler_pt log_handler;
  114.  
  115. //在这个请求中如果打开了某些资源,并需要在请求结束时释放,那么需要把定义的释放资源的方法添加到这个成员
  116. ngx_http_cleanup_t *cleanup;
  117.  
  118. unsigned subrequests:8;
  119. //引用计数一般都作用于这个请求的原始请求上
  120. //引用计数,每当派生出子请求时,原始请求的count成员都会加一
  121. unsigned count:8;
  122. //阻塞标志位,目前仅由aio使用
  123. unsigned blocked:8;
  124.  
  125. //标志位:为1表示蛋清请求正在使用异步IO
  126. unsigned aio:1;
  127.  
  128. unsigned http_state:4;
  129.  
  130. /* URI with "/." and on Win32 with "//" */
  131. unsigned complex_uri:1;
  132.  
  133. /* URI with "%" */
  134. unsigned quoted_uri:1;
  135.  
  136. /* URI with "+" */
  137. unsigned plus_in_uri:1;
  138.  
  139. /* URI with " " */
  140. unsigned space_in_uri:1;
  141.  
  142. unsigned invalid_header:1;
  143.  
  144. unsigned add_uri_to_alias:1;
  145. unsigned valid_location:1;
  146. unsigned valid_unparsed_uri:1;
  147. //标志位:为1时表示URL发生过rewrite重写
  148. unsigned uri_changed:1;
  149. //表示使用rewrite重写URL的次数
  150. unsigned uri_changes:4;
  151.  
  152. unsigned request_body_in_single_buf:1;
  153. unsigned request_body_in_file_only:1;
  154. unsigned request_body_in_persistent_file:1;
  155. unsigned request_body_in_clean_file:1;
  156. unsigned request_body_file_group_access:1;
  157. unsigned request_body_file_log_level:3;
  158.  
  159. unsigned subrequest_in_memory:1;
  160. unsigned waited:1;
  161.  
  162. #if (NGX_HTTP_CACHE)
  163. unsigned cached:1;
  164. #endif
  165.  
  166. #if (NGX_HTTP_GZIP)
  167. unsigned gzip_tested:1;
  168. unsigned gzip_ok:1;
  169. unsigned gzip_vary:1;
  170. #endif
  171.  
  172. unsigned proxy:1;
  173. unsigned bypass_cache:1;
  174. unsigned no_cache:1;
  175.  
  176. /*
  177. * instead of using the request context data in
  178. * ngx_http_limit_conn_module and ngx_http_limit_req_module
  179. * we use the single bits in the request structure
  180. */
  181. unsigned limit_conn_set:1;
  182. unsigned limit_req_set:1;
  183.  
  184. #if 0
  185. unsigned cacheable:1;
  186. #endif
  187.  
  188. unsigned pipeline:1;
  189. unsigned chunked:1;
  190. unsigned header_only:1;
  191. //标志位,为1表示当前请求时keepalive请求
  192. unsigned keepalive:1;
  193. //延迟关闭标志位
  194. unsigned lingering_close:1;
  195. //标志位:为1表示正在丢弃http请求中的包体
  196. unsigned discard_body:1;
  197. //标志位:为1表示请求的当前状态是在做内部跳转
  198. unsigned internal:1;
  199. unsigned error_page:1;
  200. unsigned ignore_content_encoding:1;
  201. unsigned filter_finalize:1;
  202. unsigned post_action:1;
  203. unsigned request_complete:1;
  204. unsigned request_output:1;
  205. //标志位:为1表示发生给客户端的http响应头已经发送
  206. unsigned header_sent:1;
  207. unsigned expect_tested:1;
  208. unsigned root_tested:1;
  209. unsigned done:1;
  210. unsigned logged:1;
  211.  
  212. //标志位,表示缓冲中是否有待发送内容
  213. unsigned buffered:4;
  214.  
  215. unsigned main_filter_need_in_memory:1;
  216. unsigned filter_need_in_memory:1;
  217. unsigned filter_need_temporary:1;
  218. unsigned allow_ranges:1;
  219.  
  220. #if (NGX_STAT_STUB)
  221. unsigned stat_reading:1;
  222. unsigned stat_writing:1;
  223. #endif
  224.  
  225. /* used to parse HTTP headers */
  226.  
  227. //状态机解析http时使用state来表示当前的解析状态,需要检查是否构成完成的http请求行
  228. ngx_uint_t state;
  229.  
  230. ngx_uint_t header_hash;
  231. ngx_uint_t lowcase_index;
  232. u_char lowcase_header[NGX_HTTP_LC_HEADER_LEN];
  233.  
  234. u_char *header_name_start;
  235. u_char *header_name_end;
  236. u_char *header_start;
  237. u_char *header_end;
  238.  
  239. /*
  240. * a memory that can be reused after parsing a request line
  241. * via ngx_http_ephemeral_t
  242. */
  243.  
  244. u_char *uri_start;
  245. u_char *uri_end;
  246. u_char *uri_ext;
  247. u_char *args_start;
  248. u_char *request_start;
  249. u_char *request_end;
  250. u_char *method_end;
  251. u_char *schema_start;
  252. u_char *schema_end;
  253. u_char *host_start;
  254. u_char *host_end;
  255. u_char *port_start;
  256. u_char *port_end;
  257.  
  258. unsigned http_minor:16;
  259. unsigned http_major:16;
  260. };

 

转http://blog.csdn.net/xiajun07061225/article/details/9189505 

  1. struct ngx_http_request_s {
  2. uint32_t                          signature;         /* "HTTP" */
  3. //请求对应的客户端连接
  4. ngx_connection_t                 *connection;
  5. //指向存放所有HTTP模块的上下文结构体的指针数组
  6. void                            **ctx;
  7. //指向请求对应的存放main级别配置结构体的指针数组
  8. void                            **main_conf;
  9. //指向请求对应的存放srv级别配置结构体的指针数组
  10. void                            **srv_conf;
  11. //指向请求对应的存放loc级别配置结构体的指针数组
  12. void                            **loc_conf;
  13. /*
  14. * 在接收完http头部,第一次在业务上处理http请求时,http框架提供的处理方法是ngx_http_process_request。
  15. 但如果该方法无法一次处理完该请求的全部业务,在归还控制权到epoll时间模块后,该请求再次被回调时,
  16. 将通过Ngx_http_request_handler方法来处理,而这个方法中对于可读事件的处理就是调用read_event_handler处理请求。
  17. 也就是说,http模块希望在底层处理请求的读事件时,重新实现read_event_handler方法
  18. */
  19. ngx_http_event_handler_pt         read_event_handler;
  20. //与上面的方法类似
  21. ngx_http_event_handler_pt         write_event_handler;
  22. #if (NGX_HTTP_CACHE)
  23. ngx_http_cache_t                 *cache;
  24. #endif
  25. //upstream机制用到的结构体
  26. ngx_http_upstream_t              *upstream;
  27. ngx_array_t                      *upstream_states;
  28. /* of ngx_http_upstream_state_t */
  29. //这个请求的内存池
  30. ngx_pool_t                       *pool;
  31. //用于接收http请求内容的缓冲区,主要接收http头部
  32. ngx_buf_t                        *header_in;
  33. //ngx_http_process_request_headers在接收、解析完http请求的头部后,会把解析完的每一个http头部加入到headers_in的headers链表中,同时会构造headers_in中的其他成员
  34. ngx_http_headers_in_t             headers_in;
  35. //http模块会把想要发送的http相应信息放到headers_out中,期望http框架将headers_out中的成员序列化为http响应包发送给用户
  36. ngx_http_headers_out_t            headers_out;
  37. //接收请求中包体的数据结构
  38. ngx_http_request_body_t          *request_body;
  39. //延迟关闭连接的时间
  40. time_t                            lingering_time;
  41. //当前请求初始化时的时间
  42. time_t                            start_sec;
  43. ngx_msec_t                        start_msec;
  44. //下面的9个成员是函数ngx_http_process_request_line方法在接收、解析http请求行时解析出的信息
  45. ngx_uint_t                        method;//方法名
  46. ngx_uint_t                        http_version;//协议版本
  47. ngx_str_t                         request_line;
  48. ngx_str_t                         uri;//用户请求中的uri
  49. ngx_str_t                         args;//用户请求中的url参数
  50. ngx_str_t                         exten;//用户请求的文件扩展名
  51. ngx_str_t                         unparsed_uri;//没有进行URL解码的原始请求
  52. ngx_str_t                         method_name;//用户请求中的方法名字符串
  53. ngx_str_t                         http_protocol;//其data成员指向请求中http起始地址
  54. /*表示需要发送给客户端的http响应。out中保存着由headers_out中序列化后的表示http头部的TCP流。
  55. * 在调用ngx_http_output_filter方法后,out中还会保存着待发送的http包体,它是实现异步发送http响应的关键。*/
  56. ngx_chain_t                      *out;
  57. /*当前请求既有可能是用户发来的请求,也可能是派生出的子请求。
  58. * 而main标识一系列相关的派生子请求的原始请求。
  59. * 一般可通过main和当前请求的地址是否相等来判断当前请求是否为用户发来的原始请求。*/
  60. ngx_http_request_t               *main;
  61. //当前请求的父请求(不一定是原始请求)
  62. ngx_http_request_t               *parent;
  63. //与subrequest子请求相关的功能
  64. ngx_http_postponed_request_t     *postponed;
  65. ngx_http_post_subrequest_t       *post_subrequest;
  66. //所有的子请求都是通过这个单链表链接起来的
  67. ngx_http_posted_request_t        *posted_requests;
  68. /*全局的ngx_http_phase_engine_t结构体中定义了一个ngx_http_phase_handler_t回答方法组成的数组。
  69. * 而phase_handler成员则与该数组配合使用。表示请求下次应当执行phase_handler作为序列号指定的数组中的回调方法*/
  70. ngx_int_t                         phase_handler;
  71. //表示NGX_HTTP_CONTENT_PHASE阶段提供给http模块处理请求的一种方式,它指向http模块实现的请求处理方法
  72. ngx_http_handler_pt               content_handler;
  73. //在NGX_HTTP_ACCESS_PHASE节点需要判断请求是否具有访问权限时,通过access_code来传递http模块的handler回调方法的返回值,如果为0表示具备权限。否则不具备。
  74. ngx_uint_t                        access_code;
  75. ngx_http_variable_value_t        *variables;
  76. #if (NGX_PCRE)
  77. ngx_uint_t                        ncaptures;
  78. int                              *captures;
  79. u_char                           *captures_data;
  80. #endif
  81. size_t                            limit_rate;
  82. /* used to learn the Apache compatible response length without a header */
  83. size_t                            header_size;
  84. //http请求的全部长度,包括http包体
  85. off_t                             request_length;
  86. ngx_uint_t                        err_status;
  87. ngx_http_connection_t            *http_connection;
  88. #if (NGX_HTTP_SPDY)
  89. ngx_http_spdy_stream_t           *spdy_stream;
  90. #endif
  91. ngx_http_log_handler_pt           log_handler;
  92. //在这个请求中如果打开了某些资源,并需要在请求结束时释放,那么需要把定义的释放资源的方法添加到这个成员
  93. ngx_http_cleanup_t               *cleanup;
  94. unsigned                          subrequests:8;
  95. //引用计数一般都作用于这个请求的原始请求上
  96. //引用计数,每当派生出子请求时,原始请求的count成员都会加一
  97. unsigned                          count:8;
  98. //阻塞标志位,目前仅由aio使用
  99. unsigned                          blocked:8;
  100. //标志位:为1表示蛋清请求正在使用异步IO
  101. unsigned                          aio:1;
  102. unsigned                          http_state:4;
  103. /* URI with "/." and on Win32 with "//" */
  104. unsigned                          complex_uri:1;
  105. /* URI with "%" */
  106. unsigned                          quoted_uri:1;
  107. /* URI with "+" */
  108. unsigned                          plus_in_uri:1;
  109. /* URI with " " */
  110. unsigned                          space_in_uri:1;
  111. unsigned                          invalid_header:1;
  112. unsigned                          add_uri_to_alias:1;
  113. unsigned                          valid_location:1;
  114. unsigned                          valid_unparsed_uri:1;
  115. //标志位:为1时表示URL发生过rewrite重写
  116. unsigned                          uri_changed:1;
  117. //表示使用rewrite重写URL的次数
  118. unsigned                          uri_changes:4;
  119. unsigned                          request_body_in_single_buf:1;
  120. unsigned                          request_body_in_file_only:1;
  121. unsigned                          request_body_in_persistent_file:1;
  122. unsigned                          request_body_in_clean_file:1;
  123. unsigned                          request_body_file_group_access:1;
  124. unsigned                          request_body_file_log_level:3;
  125. unsigned                          subrequest_in_memory:1;
  126. unsigned                          waited:1;
  127. #if (NGX_HTTP_CACHE)
  128. unsigned                          cached:1;
  129. #endif
  130. #if (NGX_HTTP_GZIP)
  131. unsigned                          gzip_tested:1;
  132. unsigned                          gzip_ok:1;
  133. unsigned                          gzip_vary:1;
  134. #endif
  135. unsigned                          proxy:1;
  136. unsigned                          bypass_cache:1;
  137. unsigned                          no_cache:1;
  138. /*
  139. * instead of using the request context data in
  140. * ngx_http_limit_conn_module and ngx_http_limit_req_module
  141. * we use the single bits in the request structure
  142. */
  143. unsigned                          limit_conn_set:1;
  144. unsigned                          limit_req_set:1;
  145. #if 0
  146. unsigned                          cacheable:1;
  147. #endif
  148. unsigned                          pipeline:1;
  149. unsigned                          chunked:1;
  150. unsigned                          header_only:1;
  151. //标志位,为1表示当前请求时keepalive请求
  152. unsigned                          keepalive:1;
  153. //延迟关闭标志位
  154. unsigned                          lingering_close:1;
  155. //标志位:为1表示正在丢弃http请求中的包体
  156. unsigned                          discard_body:1;
  157. //标志位:为1表示请求的当前状态是在做内部跳转
  158. unsigned                          internal:1;
  159. unsigned                          error_page:1;
  160. unsigned                          ignore_content_encoding:1;
  161. unsigned                          filter_finalize:1;
  162. unsigned                          post_action:1;
  163. unsigned                          request_complete:1;
  164. unsigned                          request_output:1;
  165. //标志位:为1表示发生给客户端的http响应头已经发送
  166. unsigned                          header_sent:1;
  167. unsigned                          expect_tested:1;
  168. unsigned                          root_tested:1;
  169. unsigned                          done:1;
  170. unsigned                          logged:1;
  171. //标志位,表示缓冲中是否有待发送内容
  172. unsigned                          buffered:4;
  173. unsigned                          main_filter_need_in_memory:1;
  174. unsigned                          filter_need_in_memory:1;
  175. unsigned                          filter_need_temporary:1;
  176. unsigned                          allow_ranges:1;
  177. #if (NGX_STAT_STUB)
  178. unsigned                          stat_reading:1;
  179. unsigned                          stat_writing:1;
  180. #endif
  181. /* used to parse HTTP headers */
  182. //状态机解析http时使用state来表示当前的解析状态,需要检查是否构成完成的http请求行
  183. ngx_uint_t                        state;
  184. ngx_uint_t                        header_hash;
  185. ngx_uint_t                        lowcase_index;
  186. u_char                            lowcase_header[NGX_HTTP_LC_HEADER_LEN];
  187. u_char                           *header_name_start;
  188. u_char                           *header_name_end;
  189. u_char                           *header_start;
  190. u_char                           *header_end;
  191. /*
  192. * a memory that can be reused after parsing a request line
  193. * via ngx_http_ephemeral_t
  194. */
  195. u_char                           *uri_start;
  196. u_char                           *uri_end;
  197. u_char                           *uri_ext;
  198. u_char                           *args_start;
  199. u_char                           *request_start;
  200. u_char                           *request_end;
  201. u_char                           *method_end;
  202. u_char                           *schema_start;
  203. u_char                           *schema_end;
  204. u_char                           *host_start;
  205. u_char                           *host_end;
  206. u_char                           *port_start;
  207. u_char                           *port_end;
  208. unsigned                          http_minor:16;
  209. unsigned                          http_major:16;
  210. };

nginx的ngx_http_request_t结构体的更多相关文章

  1. Nginx学习之三-ngx_http_request_t结构体

    ngx_http_request_s是nginx中非常重要的一个结构体,贯穿于htpp请求处理的整个过程中. 下面解释了ngx_http_request_s结构体中与HTTP框架相关的重要的成员变量. ...

  2. Nginx之核心结构体ngx_cycle_t

    1. ngx_listening_t 结构体 ngx_cycle_t 对象中有一个动态数组成员叫做 listening,它的每个数组元素都是 ngx_listening_t 结构体,而每个 ngx_l ...

  3. 菜鸟学习-C语言函数参数传递详解-结构体与数组 分类: C/C++ Nginx 2015-07-14 10:24 89人阅读 评论(0) 收藏

    C语言中结构体作为函数参数,有两种方式:传值和传址. 1.传值时结构体参数会被拷贝一份,在函数体内修改结构体参数成员的值实际上是修改调用参数的一个临时拷贝的成员的值,这不会影响到调用参数.在这种情况下 ...

  4. nginx取结构体地址

    linux内核提供了一个container_of()宏,可以根据结构体某个成员的地址找到父结构的地址. #define container_of(ptr, type, member) ({ \ con ...

  5. Nginx源码分析-ngx_module_s结构体

    该结构体是整个Nginx模块化架构最基本的数据结构体.它描述了Nginx程序中一个模块应该包括的基本属性,在tengine/src/core/ngx_conf_file.h中定义了该结构体 struc ...

  6. Go第六篇之结构体剖析

    Go 语言通过用自定义的方式形成新的类型,结构体是类型中带有成员的复合类型.Go 语言使用结构体和结构体成员来描述真实世界的实体和实体对应的各种属性. Go 语言中的类型可以被实例化,使用new或&a ...

  7. 06. Go 语言结构体

    Go语言结构体(struct) Go 语言通过用自定义的方式形成新的类型,结构体是类型中带有成员的复合类型.Go 语言使用结构体和结构体成员来描述真实世界的实体和实体对应的各种属性. Go 语言中的类 ...

  8. C语言根据结构体成员变量的地址,得到结构体的地址

    看nginx代码时发现双链表使用的是这种方法,记录一下 给出一个实例来说明 struct father_t {    int a;    char *b;    double c;}f;char *p ...

  9. Go结构体实现类似成员函数机制

    Go语言结构体成员能否是函数,从而实现类似类的成员函数的机制呢?答案是肯定的. package main import "fmt" type stru struct { testf ...

随机推荐

  1. babel6 的 export default bug

    把export default  变成 module.exports 就行了

  2. Mysql索引的类型和优缺点

    索引是一种特殊的文件(InnoDB数据表上的索引是表空间的一个组成部分),它们包含着对数据表里所有记录的引用指针.注:[1]索引不是万能的!索引可以加快数据检索操作,但会使数据修改操作变慢.每修改数据 ...

  3. eclipse下项目死活不编译

    工作中我们可能会遇到这种问题,项目在Eclipse下就是不编译,无论项目clean,重新build项目,重启eclipse,重启电脑都不好使.... 这时候我们可以把项目的jdk删掉,重新add一下, ...

  4. 初学者-微信小程序 问题解决办法记录

    1.tabBar不显示的问题 1),检查大小写 2),pagePath路径书写,和pages路径一样,不能多或者少一个"/"或者"?" 2.tabBar和nav ...

  5. java中的泛型和sql中的索引

    sql中的索引 索引:好处查询的速度快,被删除,修改,不会对表产生影响,作用是加速查询: 一种典型的数据库对象 作用:提交数据的查询效率,尤其对一些数据量很大的表 索引是用来为表服务的 索引是orac ...

  6. Big String-POJ2887块状数组

    Time Limit: 1000MS Memory Limit: 131072K Description You are given a string and supposed to do some ...

  7. Python 对目录中的文件进行批量转码(GBK>UTF8)

    通过python实现对文件转码,其实处理很简单: 1.打开读取文件内容到一个字符串变量中,把gbk编码文件,对字符串进行decode转换成unicode 2.然后使用encode转换成utf-8格式. ...

  8. vpsmate安装

    安装需求 操作系统:CentOS/Redhat 5.4 或 5.4 以上版本,32位或64位均可,推荐使用 CentOS 6.2 64位. 内存大小:运行时占用约 20MB 左右的服务器内存. 请使用 ...

  9. 关于ios苹果系统的中的右键事件,查遍了全网都没有的小技巧。

    前阵子公司要求写一套手机端,兼容各种平台和系统,当然,pc端也没有放过. 我用了bootstrap框架和jq.在安卓中的右键事件只需要取消浏览器默认事件,然后长按就可以触发pc端的右键事件,非常好,一 ...

  10. U盘插入电脑后,提示需要格式化U盘如何解决?

    未弹出U盘就拔掉U盘,有可能会破坏U盘的分区表.当再次把U盘插入电脑时,会提示需要格式化U盘,这是什么情况,如何解决呢?其实只要用DiskGenius硬盘恢复软件就可以解决这个问题.下面和小编一起来看 ...