Start

2023年10月20日星期五

atom keybind

'atom-text-editor':
"ctrl-space": "unset!"
'alt-/': 'autocomplete-plus:activate'

2022年8月22日星期一

// 校正命令模式的 dir
chdir(__DIR__);

function is_cli() {
if (php_sapi_name() === 'cli') {
    return true;
}
if (defined("STDIN")) {
    return true;
}
if (!isset($_SERVER["REMOTE_ADDR"]) || empty($_SERVER["REMOTE_ADDR"])) {
    return true;
}
return false;
}

php include, require 路徑問題

PHP中include和require絕對路徑、相對路徑問題
-Advertisement-
Play Games
在寫PHP程式時，經常要用到include或require包含其他文件，但是各文件里包含的文件多了之後，就會產生路徑問題。如下目錄： <web>(網站根目錄) ├<A>文件夾 │ │ │ └1.php ├<B>文件夾 │ │ │ └2.php └index.php 現在根目錄下的index.php ...

在寫PHP程式時，經常要用到include或require包含其他文件，但是各文件里包含的文件多了之後，就會產生路徑問題。

如下目錄：

<web>(網站根目錄)
├<A>文件夾
│ │
│ └1.php
├<B>文件夾
│ │
│ └2.php
└index.php

現在根目錄下的index.php要包含A文件夾內的1.php文件，則用include "./A/1.php"即可

而1文件夾內的1.php又包含了B文件夾內的2.php，則1.php內寫上include "../B/2.PHP"即可

可是要知道，當index.php包含了1.php之後，編譯是在index.php里進行的

也就是index.php所包含文件里的include都是相對於index.php的

那麼1.php被包含進index.php里了，那麼就要相對於index.php尋找2.php了
而上面說了，1.php里寫的是include "../B/2.php"，現在編譯文件已經相對於網站根目錄了（即相對於index.php）
"../"則意味著還要再返回上一級目錄尋找，那麼怎麼會找得到。

在網上也尋找過一些方法，最好的辦法還是都採用絕對路徑方法較妥。
可以定義一個單入口文件，將要包含的文件包含進來
定義一個常量define("__ROOT__",dirname(__FILE__));，那麼在寫後面的文件過程中，只需要採用絕對方式，加上__ROOT__就行了。

require dirname(__FILE__) . '/library/Zend/Loader.php';

2022年8月8日星期一

x-debug 歷史版本

https://xdebug.org/download/historical

2021年9月15日星期三

openjdk

https://jdk.java.net/

2021年8月14日星期六

(node.js impoet)filename, dirname

import { dirname } from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);

const __dirname = dirname(__filename)

2020年10月16日星期五

https://photoswipe.com/

https://github.com/dimsemenov/PhotoSwipe

2020年6月9日星期二

JavaScript module 循環引用的問題

2020年5月28日星期四

project 對 dom.tree 先廣域搜索指定的節點，再排序

const getCommentLis = {

            main(root) {

                let commentList = [];

                let dataList = [{

                    level: [1],

                    node: root

                }];

                // 位數

                let digit = dataList[0].level.length;

                let i = 0;

                let data;

                while (null != (data = dataList[i++])) {

                    // debugger;

                    const level = data.level;

                    const node = data.node;

                    if (node.tagName != null) {

                        node.childNodes.forEach((child, i) => {

                            let _level = level.slice()

                            _level.push(i + 1);

                            if (_level.length > digit) {

                                digit = _level.length;

                            }

                            dataList.push({

                                level: _level,

                                node: child

                            });

                        });

                    } else {

                        if (node.nodeType == 8) {

                            let parent = node.parentNode;

                            commentList.push({

                                parent: parent,

                                node: node,

                                level

                            });

                        }

                    }

                } // endWhile

                // debugger;

                console.dir(commentList);

                commentList.sort((a, b) => {

                    if (Array.isArray(a.level)) {

                        a.level = this.getLevel(digit, a.level);

                    }

                    if (Array.isArray(b.level)) {

                        b.level = this.getLevel(digit, b.level);

                    }

                    return (a.level - b.level);

                });

                console.dir(commentList);

                return commentList;

            },

            getLevel(digit, level) {

                debugger;

                let j = digit - level.length;

                // debugger;

                // 基數

                let p = 1;

                for (let i = 0; i < j; i++) {

                    p *= 10;

                }

                // debugger;

                let res = 0;

                let num;

                while (null != (num = level.pop())) {

                    res = res + num * p;

                    // 十進位

                    p *= 10;

                }

                return res;

            }

        }

2019年9月28日星期六

php namespace 的引用

2019年9月25日星期三

php get_headers 判斷URL是否有效

在php中判斷一個文件或目錄是否存在，大家通常都會想到is_file和file_exists兩個函數。但這兩個函數再判斷一個遠程url文件是否存在的問題上還是會存在這樣那樣的問題。這裡作者將和大家分享一種利用php get_headers函數來判斷遠程url文件是有效否存在的辦法。

關於php get_headers函數的作用及用法，可以參考本站文章：

php get_headers函數的作用及用法

下面來具體說如何利用php get_headers卻判斷url的真實有效性。

通過該函數的介紹，我們可以知道對於這個函數簡單的說就是它返回的是一個HTTP請求的頭文件信息，信息格式基本如下：

（1）

Array
(
    [0] => HTTP/1.1 200 OK
    [1] => Date: Sat, 29 May 2004 12:28:13 GMT
    [2] => Server: Apache/1.3.27 (Unix) (Red-Hat/Linux)
    [3] => Last-Modified: Wed, 08 Jan 2003 23:11:55 GMT
    [4] => ETag: "3f80f-1b6-3e1cb03b"
    [5] => Accept-Ranges: bytes
    [6] => Content-Length: 438
    [7] => Connection: close
    [8] => Content-Type: text/html
)

（2）

Array
(
    [0] => HTTP/1.0 404 Not Found
    [1] => Date: Sat, 29 May 2004 12:28:13 GMT
    [2] => Server: Apache/1.3.27 (Unix) (Red-Hat/Linux)
    [3] => Last-Modified: Wed, 08 Jan 2003 23:11:55 GMT
    [4] => ETag: "3f80f-1b6-3e1cb03b"
    [5] => Accept-Ranges: bytes
    [6] => Content-Length: 438
    [7] => Connection: close
    [8] => Content-Type: text/html
)

從以上兩種情況可以很容易看出，如果判斷該url是否有效存在肯定是通過數組中的第一個元素值來判斷的。服務器返回 200 即文件正確返回的意思，服務器返回 404 即文件不存在，因此從這個地方就可以很容易的判斷一個url的是否存在了

2019年5月21日星期二

合乎規格的標籤

/<!([\s\S]{0,}?)>|<([a-z][\s\S]{0,}?)(?:\s[\s\S]{0,}?|)([\/]?)>|<\/([a-z][\s\S]{0,}?)>/g

2019年3月14日星期四

堆疊樹

// 堆疊樹(由下往上)

// (1~n) m 的子節點為 2m, 2m+1
// 階層從 1階開始
// 每階最多 (2(level-1)次方) 個節點
let data = [26, 5, 19, 1, 61, 11, 59, 15, 48, 77];

// 最後一個有子節點的節點
let lastParentIndex = Math.floor(data.length / 2) - 1;

console.log(JSON.stringify(data));
// 往前拜訪每個有孩子的節點
for (let i = lastParentIndex; i >= 0; i--) {
    debugger;
    check(i, data);
}
console.log(JSON.stringify(data));

//----------------------------
// 檢查父節點與子節點的大小
function check(parent_index, _data) {
    debugger;

    // 會不斷往下有子節點的節點探索
    while (parent_index <= lastParentIndex) {

        let leftIndex = (parent_index + 1) * 2 - 1;
        let rightIndex = leftIndex + 1;

        // 可能沒有 right 子節點
        rightIndex = (rightIndex >= _data.length) ? null : rightIndex;

        // console.log('%d = %d', _data[leftIndex], _data[rightIndex]);

        let maxIndex = (rightIndex == null || (_data[leftIndex] > _data[rightIndex])) ? leftIndex : rightIndex;

        if (_data[parent_index] < _data[maxIndex]) {
            // 交換
            let temp = _data[maxIndex];
            _data[maxIndex] = _data[parent_index];
            _data[parent_index] = temp;
        }

        // 往下層比較
        // 確定變動的節點要比他的子節點大
        parent_index = maxIndex;
    }
}
------------------------------------------------------------------------
// 堆疊樹(由上往下)

// (1~n) m 的子節點為 2m, 2m+1
// 階層從 1階開始
// 每階最多 (2(level-1)次方) 個節點
let data = [26, 5, 19, 1, 61, 11, 59, 15, 48, 77];

console.log(JSON.stringify(data));
// 往前拜訪每個有孩子的節點
for (let i = 0; i < data.length; i++) {
    debugger;
    check(i, data);
}
console.log(JSON.stringify(data));

//----------------------------
// 檢查父節點與子節點的大小
function check(parent_index, _data) {
    debugger;

    let prev_index;

    // 會不斷往下有子節點的節點探索
    while (parent_index >= 0) {

        if (prev_index != null) {
            // 回朔只需比對上一個子節點
            if (_data[parent_index] < _data[prev_index]) {
                // 交換
                let temp = _data[prev_index];
                _data[prev_index] = _data[parent_index];
                _data[parent_index] = temp;
            }

        } else {
            // 第一次進入

            let leftIndex = (parent_index + 1) * 2 - 1;
            let rightIndex = leftIndex + 1;

            leftIndex = (leftIndex >= _data.length) ? null : leftIndex;
            rightIndex = (rightIndex >= _data.length) ? null : rightIndex;

            if (leftIndex == null && rightIndex == null) {
                // 都沒有子節點
                return;
            }

            console.log('%d(%d,%d)', _data[parent_index], _data[leftIndex], _data[rightIndex]);

            let maxIndex = (rightIndex == null || (_data[leftIndex] > _data[rightIndex])) ? leftIndex : rightIndex;

            if (_data[parent_index] < _data[maxIndex]) {
                // 交換
                let temp = _data[maxIndex];
                _data[maxIndex] = _data[parent_index];
                _data[parent_index] = temp;
            }
        }
        //-----------------------
        prev_index = parent_index;
        // 往下層比較
        // 確定變動的節點要比他的子節點大
        let nextCheckIndex = Math.floor((parent_index + 1) / 2) - 1;

        if (nextCheckIndex == parent_index && parent_index == 0) {
            // 只為了解決無限迴圈
            return;
        }

        // 往上
        parent_index = nextCheckIndex;
    }
}

訂閱：文章 (Atom)

Start

2023年10月20日星期五

atom keybind

2022年8月22日星期一

php 命令模式（路徑問題）

php include, require 路徑問題

2022年8月8日星期一

x-debug 歷史版本

2021年9月15日星期三

openjdk

2021年8月14日星期六

(node.js impoet)filename, dirname

2020年10月16日星期五

https://photoswipe.com/

2020年6月9日星期二

JavaScript module 循環引用的問題

2020年5月28日星期四

project 對 dom.tree 先廣域搜索指定的節點，再排序

2019年9月28日星期六

php namespace 的引用

2019年9月25日星期三

php get_headers 判斷URL是否有效

2019年5月21日星期二

合乎規格的標籤

2019年3月14日星期四

堆疊樹

熱門文章

2023年10月20日 星期五

2022年8月22日 星期一

2022年8月8日 星期一

2021年9月15日 星期三

2021年8月14日 星期六

2020年10月16日 星期五

2020年6月9日 星期二

2020年5月28日 星期四

2019年9月28日 星期六

2019年9月25日 星期三

2019年5月21日 星期二

2019年3月14日 星期四

2023年10月20日星期五

2022年8月22日星期一

2022年8月8日星期一

2021年9月15日星期三

2021年8月14日星期六

2020年10月16日星期五

2020年6月9日星期二

2020年5月28日星期四

2019年9月28日星期六

2019年9月25日星期三

2019年5月21日星期二

2019年3月14日星期四