在线观看不卡亚洲电影_亚洲妓女99综合网_91青青青亚洲娱乐在线观看_日韩无码高清综合久久

localeCompare 可以指定你自己的排序方式，就像1L說的那樣，默認(rèn)的排序方式是根據(jù)ASCII碼去排序，不一定是你想要的需求，可以自定義，按你自己的需求。

$a = 1 || $b = 1 可以看成 $a = （1 || $b = 1），$a = true;
對PHP不熟，但是如果你自己實現(xiàn)過四則運算，這問題其實很簡單。：）

單純前端解決不了吧，我記得proxytable本身只是為了開發(fā)時使用的，他本身是處理了跨域的一些問題的。你在build之后就和他沒關(guān)系了，相當(dāng)于只是一個js去執(zhí)行。
不知道你前端頁面是用什么起的服務(wù)，如果是用的nginx的話，可以在里面做一個反向代理。在不就是通過服務(wù)端做CORS了。

1. fork到自己的庫
2. 檢出剛才自己的庫
3. 新建分支，編碼提交
4. push剛才新建的分支
5. 到github上去點pull request等待原倉庫合并

首先，解決問題

遇到類似問題，官方文檔往往是最好的解答。試下把你的代碼改成下面這樣，唯一的不同，就是把form的實例化挪動動 upload 里。

  // 上傳圖片
  upload: (req, res, next) => {

    const form = new formidable.IncomingForm() // 注意，把form 的實例化操作挪進(jìn)來

    //上傳文件的保存路徑
    form.uploadDir = path.dirname('./upload/upload/')
    //保存擴展名
    form.keepExtensions = true
    //上傳文件的最大大小
    form.maxFieldsSize = 20 * 1024 * 1024
    form.parse(req, (err, fields, files) => {
      
      // 項目未打包時使用
      const imagepath = 'http://localhost:8088/' + path.normalize(files.file.path)
      // 項目打包到server之后使用
      // const imagepath = path.normalize(files.file.path)
      res.status(200).send(imagepath)
      // return next()
    })
    
  },

官方文檔在 這里，仔細(xì)看兩眼就會發(fā)現(xiàn)你的代碼跟它的差別。

其次，探究問題根源

如果好奇問題出在哪里，可以看下 formidable 的源碼，incoming_form.js。

因為你所有的parse操作都是在同一個form實例上進(jìn)行，因此，this.on('end') 會被調(diào)用多次。

1. 第一次上傳：注冊'end'回調(diào)，假設(shè)回調(diào)為 cb1。文件上傳成功，cb1調(diào)用
2. 第二次上傳：新增'end'回調(diào)，假設(shè)回調(diào)為 cb2。由于 this.on() 注冊是累加的，當(dāng)前end事件的回調(diào)有兩個，cb1、cb2。文件上傳成功，cb1首先被調(diào)用，然后就悲劇了

IncomingForm.prototype.parse = function(req, cb) {

  // 忽略一堆無關(guān)緊要的代碼....

  // 注冊各種回調(diào)，同樣忽略掉無關(guān)緊要的代碼
  if (cb) {
      this.on('end', function() {
        cb(null, fields, files);
      });
  }

因為訪問太頻繁，被臨時 BAN 了？

可以寫成 handler的形式，參考http.TimeoutHandler的實現(xiàn)方式，你可以寫一個 CorsHandler,
然后包一下你的articleController.Show 或者 articleController.Edit

對圖像進(jìn)行二值化，然后遍歷并比較左右兩部分的有效像素數(shù)量

參與匹配的玩家都丟入匹配池，每個玩家記錄兩個屬性（分?jǐn)?shù)、開始匹配的時間），每秒遍歷匹配池中所有分?jǐn)?shù)段，找出每個分?jǐn)?shù)上等待時間最長的玩家，用他的范圍來進(jìn)行匹配（因為匹配范圍會因為等待時間邊長而增加，等待時間最長的的玩家匹配范圍最大，如果連他都匹配不夠，那同分?jǐn)?shù)段的其他玩家就更匹配不夠了）。如果匹配到了足夠的人，那就把這些人從匹配池中移除，匹配成功；如果匹配人到的人數(shù)不夠并且沒有達(dá)到最大匹配時間，則跳過等待下一秒的匹配；如果達(dá)到最大匹配時間，還是沒匹配到足夠的人，則給這個幾個人湊機器人，提交匹配成功。并且根據(jù)匹配的等待時間擴大匹配范圍，直到匹配到足夠的人（或者超過一定時間還沒湊夠人，則補AI機器人）

謝邀，這個找一下狠多的吧。
zhihu-python

zhihu-api

動態(tài)組件介紹

<template>
         <router-link :to="{path,query:{id}}"></router-link>
         <component v-bind:is="currentView">
          <!-- 組件在 vm.currentview 變化時改變！ -->
        </component>
     </template>
     <script>
         var home = {
          template: '<p>Welcome home!</p>'
        }
        var list = {
          template: '<p>Welcome list!</p>'
        }
        var detail = {
          template: '<p>Welcome detail!</p>'
        }
         export default {
             props:{
                 path:{
                    type:String,
                       default:'/page/1'
                },
                 id:{
                    type:String,
                       default:'1'
                }
             },
             watch: {
             　　'$route' (to, from) {
             　　        switch(this.$route.query.id){
                        case '1':this.currentView = home;break;
                        case '2':this.currentView = list;break;
                        case '3':this.currentView = detail;break;
                        default:this.currentView = home;
                    }
             　　}
            },
            data(){
                  return{
                      currentView: home
                  }
            }
         }
     </script>

http://pecl.php.net/package/r...

搜了一些資料，應(yīng)該是沒有這種寫法。我做的就是從數(shù)據(jù)庫取的時候是按照第一個排序條件，拿出數(shù)據(jù)之后，自己又寫了一個排序的函數(shù)，針對第二個條件進(jìn)行排序。

新建axis時有用stack，在原有的某axis上拼接用concat

ReLu雖然在大于0的區(qū)間是線性的，在小于等于0的部分也是線性的，但是它整體不是線性的，因為不是一條直線。

多個線性操作的組合也是一個線性操作，沒有非線性激活，就相當(dāng)于只有一個超平面去劃分空間。但是ReLu是非線性的，效果類似于劃分和折疊空間，組合多個（線性操作 + ReLu）就可以任意的劃分空間。

很多ReLU改進(jìn)版：leaky relu、prelu、elu、crelu……各有各的效果和性能，都不比為relu常見：

1. 不一定有效，例如沒遇到dying relu，就沒必要用leaky relu，用了也不一定會更好
2. 更復(fù)雜、性能不如relu

參考：

1. How Do Neural Networks Work?

我覺得應(yīng)該是數(shù)據(jù)庫的連接寫入有問題，但是還是沒轍啊我

我自己琢磨出了一種辦法，不知道可行否。
我生成3個客戶端：

• 處理正常req,res請求的

• 發(fā)布消息的

• 訂閱消息的

我本來想用訂閱消息的redis客戶端來處理正常req,res請求但是報錯：

ReplyError: ERR only (P)SUBSCRIBE / (P)UNSUBSCRIBE / PING / QUIT
allowed in this context

后來才知道，原來如果客戶端用于訂閱消息就不能下其他命令進(jìn)行CRUD。
所以才要再建一個客戶端處理正常的req, res請求。

下面是代碼：

var redis = require('redis');
var express = require('express');
var app = express();
var clientSub = redis.createClient(6379, 'localhost');
var clientPub = redis.createClient(6379, 'localhost');
var clientRes = redis.createClient(6379,'localhost');

clientRes.on('ready', function(err){
    console.log('hello, i handle req/res');
});

clientPub.on('ready', function (err) {
    console.log('hello, i publish');
});

clientSub.on('ready', function (err) {
    console.log('hello, i subscribe');
});

clientSub.subscribe('channel1');

clientSub.on('subscribe', function (channel, count) {
    console.log(`got subscribe event: ${channel} and count is ${count}`);
    setInterval(()=>{
        clientPub.publish('channel1', `hi, i am channel one, message at ${new Date()}`);
    }, 2000);
});

clientSub.on('connect', function () {
    clientSub.on('message', function (channel, message) {
        var response = `received message from ${channel}:${message}`;
        clientRes.lpush('myResponse', response,redis.print);
    });
});

app.get('/', function (req, res) {
    clientRes.lrange('myResponse',0,-1, function(err, result){
        console.log(result[result.length])
        res.send(typeof result);
    })  
})

app.listen(1338, function () {
    console.log('App listening on port 1338!');
});

沒想到SF有Haskell問題：）

其實你看Profiling的結(jié)果，in_range的inherited %time和inherited %alloc都比larger_than大，占了整個程序執(zhí)行的100%和93.3%。所以第一種方法快。

寫個rewrite rule也許可以對elem和enumFromTo進(jìn)行優(yōu)化。

試了寫rewrite rule，發(fā)現(xiàn)enumFromTo有inline，導(dǎo)致rewrite rule沒有生效，所以先自己實現(xiàn)一個myEnumFromTo看看效果：

module Main where

{-# RULES
   "elem/myEnumFromTo" forall (x::Integer) (n::Integer) (m::Integer) . elem x (myEnumFromTo n m) = x >= n && x <= m 
#-}

{-# NOINLINE myEnumFromTo #-}
myEnumFromTo n m
  | n == m = [n]
  | otherwise = [n] ++ myEnumFromTo (n + 1) m

main = do
  print $ {-# SCC larger_than  #-} lth 100000000
  print $ {-# scc in_range #-} inr     100000000

lth :: Integer -> Bool
lth x = (x >= 1 && x <= 65535000000000)

inr :: Integer -> Bool
inr x = let m = 65535000000000::Integer in
  x `elem` (myEnumFromTo 1 m)

Profile結(jié)果是這樣的:

main        Main             app/Main.hs:(12,1)-(14,48)    0.0   15.8


                                                                                   individual      inherited
COST CENTRE    MODULE                SRC                        no.     entries  %time %alloc   %time %alloc

MAIN           MAIN                  <built-in>                 144          0    0.0   29.6     0.0  100.0
 CAF           GHC.Conc.Signal       <entire-module>            252          0    0.0    0.9     0.0    0.9
 CAF           GHC.IO.Encoding       <entire-module>            241          0    0.0    3.8     0.0    3.8
 CAF           GHC.IO.Encoding.Iconv <entire-module>            239          0    0.0    0.3     0.0    0.3
 CAF           GHC.IO.Handle.FD      <entire-module>            231          0    0.0   47.3     0.0   47.3
 CAF           GHC.IO.Handle.Text    <entire-module>            229          0    0.0    0.1     0.0    0.1
 CAF           GHC.Show              <entire-module>            214          0    0.0    0.4     0.0    0.4
 CAF           GHC.Event.Thread      <entire-module>            193          0    0.0    1.7     0.0    1.7
 CAF           GHC.Event.Poll        <entire-module>            160          0    0.0    0.1     0.0    0.1
 CAF:main1     Main                  <no location info>         286          0    0.0    0.0     0.0    0.0
  main         Main                  app/Main.hs:(12,1)-(14,48) 288          1    0.0    0.0     0.0    0.0
 CAF:main2     Main                  <no location info>         284          0    0.0    0.0     0.0    0.0
  main         Main                  app/Main.hs:(12,1)-(14,48) 293          0    0.0    0.0     0.0    0.0
   in_range    Main                  app/Main.hs:14:32-48       294          1    0.0    0.0     0.0    0.0
    inr        Main                  app/Main.hs:(20,1)-(21,29) 295          1    0.0    0.0     0.0    0.0
     inr.m     Main                  app/Main.hs:20:13-39       296          1    0.0    0.0     0.0    0.0
 CAF:main4     Main                  <no location info>         285          0    0.0    0.0     0.0    0.0
  main         Main                  app/Main.hs:(12,1)-(14,48) 290          0    0.0    0.0     0.0    0.0
   larger_than Main                  app/Main.hs:13:36-48       291          1    0.0    0.0     0.0    0.0
    lth        Main                  app/Main.hs:17:1-39        292          1    0.0    0.0     0.0    0.0
 main          Main                  app/Main.hs:(12,1)-(14,48) 289          0    0.0   15.8     0.0   15.8

還不知道怎讓才能對enumFromTo生效:(

https://doc.webpack-china.org...

使用環(huán)境變量

官方示例是在配置文件中導(dǎo)出函數(shù)代替導(dǎo)出對象，在函數(shù)里是可以直接訪問到mode的

module.exports = (env, argv) => ({
  // ... 其他配置
  optimization: {
    minimize: false,
    // 使用 argv 來獲取 mode 參數(shù)的值
    minimizer: argv.mode === 'production' ? [
      new UglifyJsPlugin({ /* 你自己的配置 */ }), 
      // 僅在我們要自定義壓縮配置時才需要這么做
      // mode 為 production 時 webpack 會默認(rèn)使用壓縮 JS 的 plugin
    ] : [],
  },
})...

12306是怎么實現(xiàn)的，每次買之前都去數(shù)據(jù)庫查一下，看看狀態(tài)對不對。狀態(tài)對了，就讓你買。不對就顯示被預(yù)定了