__{ideal}__Javascript

//biến trong hàm không phân tán (vẫn là chính nó) khi gọi lại hàm.

function t1(m){
var d=[];
if(typeof m !=='object') d.push(m);
else
{
for(var i in m) t1(m[i]);
return d;
}
}
alert(t1(['a','b','c']).length);

//các biến trong hàm thuộc bản sao (instance) sẽ bị phân tán, khi truy cập lại hàm thông qua instance.
function lop1()
{
this.ham1(n){
var _array=[];
if(typeof n!='object') _array.push(n);
else for(var i in n) new lop1().ham1(n[i]);
}
}


//khi gọi lại hàm, thì các khu vực đều có số lần gọi bằng nhau.

function t1(m){
if(typeof m=='object')
{
for(var i in m) t1(m[i]);
}
alert('');
}
t1(['a','b']); ->gọi 3 lần alert('').

/*khi tạo instance thì toàn bộ thuộc tính, phương thức của lớp (hàm) tách biệt với thành phần thông thường có trong lớp. Note: nếu gọi thông thường thì từ khóa this không có tác dụng.
*/

function ham()
{
this.item1();
}


function lopA()
{
this.item1=function(){alert("Hello i'm item1");}
ham();
}

lopA();   //TH 1: Ok. Note: có thể sử dụng item1().
new lopA();   //TH 2: tạo instance. -> failure. Vì phương thức item1 tách biệt & thành phần thông thường ham không thể tìm thấy item1.

//javascript sử lý đối tượng ở nơi mà đối tượng tạo ra.

function b(){alert(y);}
function a()
{
var y='y';
b(); //lỗi vì nơi tạo hàm b ko biết biến y
}
a();

//

Read More

__{api}__Javascript

Note:
Bài viết dưới đây sử dụng trình duyệt Mozila, không hỗ trợ cho IE.


//lấy tên trình duyệt
navigator.appName=='netscape | IE...'

//lấy/thiết lập vị trí thanh cuộn đối với thành phần loại container: div, textarea,..
obj.scrollTop;

//lựa chọn vị trí của chuỗi đã chọn trong thành phần nhập liệu form.
obj.selectionStart;
obj.selectionEnd;

//lựa chọn 1 đoạn chuỗi trong thành phần nhập liệu.
obj.setSelectionRange(10, 20);

//gọi hàm & đồng thời  sử dụng.kế thừa đối tượng instance vào trong hàm.

function sayColor(sPrefix, sSuffix) {
    alert(sPrefix + this.color + sSuffix);
};
var obj = new Object();
obj.color = 'red';


sayColor.apply(obj, new Array('The color is ',', a very nice color indeed.'));

//kiểm tra có phải là thành phần/thuộc tính/phương thức của đối tượng.
<input id='but1' type='button' value='Hello !'/>
<script>

function A()
{
this.item='_item';
}

var b=document.getElementById('but1');
var b1=new A();



alert(('onclick' in b));
alert(('item' in b1));



</script>

//kế thừa lớp A vào lớp B, A & B đều truy cập được lẫn nhau
function lopA(){}
function lopB(){}


lopB.prototye=new lopA;

/*Khi định nghĩa: thành phần trong lớp thì (đề nghị) sử dụng định danh từ khóa this,
Khi gọi xuống lớp dưới: lớp trên muốn sử dụng được lớp dưới (trong kế thừa) thì phải sử dụng this.
Còn gọi lên lớp trên  (đề cử) nếu thành phần không thuộc lớp thì sử dụng định danh.
*/
function A()
{
   var p=this;
   p.itemA1=function(){ alert(p.itemB1);alert(this.itemB1);}
}
function B()
{
   var p=this;
   p.itemB1='itemB1';
}


B.prototype=new A;
var o=new B();
o.itemA1();   //-> output: undefined.

//javascript linh hoạt trong việc thiết lập thuộc tính cho đối tượng.
obj.ten_thuoc_tinh=gia_tri;

/*this chỉ instance (bản sao) của lớp hiện tại với điều kiện nằm trong thành phần public của lớp, không nó hiểu  là đối tượng DOMWindow.
*/

function a()
{
var p=this;
p.O='O';

function t1(){alert(this.O);}
p.t2=function(){alert(this.O);}
t1();
p.t2();
}
new a();


//có thể tạo thành phần khác bên trong 1  thành phần của lớp.
function A()
{
   this.t1=function()
   {
      this.t2='t2';
   }
   this.t1();
   alert(this.t2);
}
new A();

//

Read More

__{ideal-api}__Các thành phần trong Html

Form
//thành phần nhập liệu của form
<textarea></textarea>
<input type='text'/>

//

Read More

__{ideal}__Lối lập trình Java

Quy ước:
- Từ gạch chân trong phần mô tả code là ý tiêu đề của phần code đó.
- Mầu tím: khái niệm, các định nghĩa.

---

Tìm hiểu sơ qua:
Ý tưởng: Java được thiết kế bởi các class riêng rẽ, giống MFC (C++) là cách lập trình hướng đối tượng khá hay.
*Thiết kế 1 or nhiều lớp vào 1 file & có 1 lớp chính có Tên lớp trùng với tên của file. ie:
ví dụ:
Nội dung của file: lop1.java
class lop1{
//do-here
}
Note:
+File nguồn chứa code có định dạng .java , sau khi biên dịch & chạy thì trở thành file .class
+Khi chạy vào file sẽ chạy vào lớp chính đầu tiên (gọi là lớp đầu vào). Gọi vào hàm:
public static void main(String[] args) {

}
=> Không được thay đổi cấu trúc của hàm main.
Vì hàm này không phải là constructor của lớp, hàm này tách biệt với lớp. Muốn kích hoạt lớp phải tạo instance cho lớp.
Ví dụ:

public class vd {
    public vd(){
    System.out.print("constructor \n");
    }
    public static void main(String[] args) {
    vd t=new vd();
    // TODO, add your application code
    System.out.println("skfhguidsfs");
    }
}
+ Định danh nghĩa quyền cho các đối tượng: public, protected, private, abstract, final => sẽ áp dụng cho từng loại đối tượng sẽ tìm hiểu kỹ dưới đây.

------------------------------------------------------------------------------------------------------------

/*Điểm lưu ý:
-Thành phần, đối tượng trong java không được khai báo lại .
-Có phân biệt chữ hoa, chữ thường.
-Đối tượng trong java phải thiết lập giá trị or được khởi tạo mới có thể sử dụng được.
ie:
*/
int i;
System.out.print(i);   //lỗi.

/*java khá linh hoạt, trong việc sử dụng giá trị & biến là sử dụng biến cũng như giá trị của nó.
ie:
*/
String str="hoang";
str.getClass();
or:
"hoang".getClass();

/*
java cũng khá linh hoạt trong việc chuyển tiếp các đối tượng. Có thể chuyển tiếp ngay, chứ không cần nhớ vào 1 đối tượng khác.
ie: hàm A trả về đối tượng A1, đối tượng A1 có thành phần B.
*/
A().A1.B
new Lop1().ham1();

Kiểu dữ liệu

/*Note:
- java không tự động chuyển kiểu. ie: kiểu int không tự động chuyển được sang kiểu boolean.
*/

//Kiểu số:

int, long: kiểu số nguyên.

float, double : số thực.

- Sử dụng các phép toán cộng, trừ, nhân, chia, số dư.

//Kiểu chuỗi:

char, String: kiểu chuỗi.

//Không kiểu:

void: không có kiểu. Chỉ áp dụng cho hàm.

//Kiểu đúng/sai:

boolean: Kiểu đúng/sai.

-Chỉ chứa 2 giá trị true/false không được chứa kiểu int & tất nhiên không chuyển được sang kiểu int.

//Kiểu rỗng:

-Chuỗi rỗng: ""

-null: là dạng kiểu chuỗi or đối tượng, nó được gán để xóa giá trị của biến.

ie: 

int t;

t=null;  //sai vì null không phải là kiểu số.

Ngoài ra còn có các kiêu đối tượng lớp, cấu trúc tự định nghĩa:

/*nguyên tắc chuyển kiểu: A chuyển được về B khi B được kế thừa vào A. Hay nói cách khác: B bao A thì B chuyển được về kiểu A. Ngược lại thì không.
*/

class B extends A{}

A ham1(){

     B bien=new B();

     return bien;

}

Hàng xóm, phạm vi biến

/*Một số lưu ý:

- Biến trong java không tự khai báo.

- Biến được khai báo ở  phạm vi trong đối tượng, lệnh nào thì chỉ sử dụng riêng cho nó.
- Tuân theo quy tắc đặt tên biến chung như: không được trùng với từ khóa, không bắt đầu bằng số, không được viết cách....sử dụng ký tự đặc biệt.

- Các danh nghĩa cho đối tượng gồm: public, private, protected, abstract, final, static
Trong đó:
//Các thành phần của lớp được sử dụng:
public, private, protected, final, static


//các biến thông thường được sử dụng.
final


//danh nghĩa dùng cho class
public, abstract, final


Note: Có thể sử dụng danh nghĩa or không.

*/

for(int i=0;i<10;i++);  //i chỉ sử dụng trong for.

System.out.print(i);  //lỗi vì i không tìm thấy.

//Khai báo biến sử dụng thông thường, sử dụng danh nghĩa or không.

Kieu_du_lieu Ten_bien;

//Khai báo nhiều biến có cùng kiểu
Kieu_du_lieu bien1, bien2,...;

//khai báo đồng thời gán giá trị cho biến.

type var=value;

Làm việc với số

//Cộng, trừ, nhân, chia & lấy dư.
1+2;
2-1;
3*4;
6/2;
6%4;

/*Tăng/giảm với 1.
lấy giá trị của i trước sau đó tăng i thêm 1
*/
i++;

//cộng thêm 1 vào i, sau đó lấy giá trị mới của i.
++i;
=>tương tự với trừ.

Làm việc với chuỗi

- Chuỗi được đưa vào trong dấu ngoặc "", không được đưa vào 2 dấu nháy đơn -> chỉ dành cho 1 ký tự.

- Kết hợp công chuỗi sử dụng +. ie: "a"+"b

Lệnh của ngôn ngữ

//Lệnh hay còn gọi là biểu thức. Mỗi một lệnh kết thúc bởi dấu ;
lenh1;
lenh2;

So sánh hơn, bé, hoặc bằng
//lớn, lớn hơn or bằng.
>, >=

//bé, bé hơn or bằng.
<, <=

Bằng 100%
//Kiểu thông thường.
==


//biến bien có phải là bản sao (instance) của Kiểu lớp.
bien instanceof Lop1;

Không phải nó
//khác
!=


//phủ định
!
-----------------------------------------------

//Điều kiện hoặc, và
||, &&

Biểu thức điều kiện:


/*ký hiệu: <condition>
Là gồm các đối tượng kết hợp với nhau tạo thành biểu thức. Biểu thức này được đánh giá  giá trị về kiểu boolean true/false.
note: biểu thức chỉ là điều kiện khi nó được định giá trị về kiểu boolean (true/false).
*/
3+4 < 10   //true.

Phép gán
//chỉ gán giá trị vào biến. Sử dụng dấu '='
int a=10;


//không được gán kiểu.
Object a=int;  //sai.


//lấy biến đó & thực hiện phép toán sau đó gán trở lại.
t+=10;
=> tương tự với: -=, /=, *=, %=

Lệnh Điều kiện
//sử dụng khối (blocks) nếu có nhiều lệnh.
//dạng 1
if(<condition>){ //lệnh đúng;}

//dạng 2
if(<condition>){//lệnh đúng;}else {//lệnh sai; }

//dạng 3: ngắn gọn
<condition>? true : false;

Lệnh Rẽ nhánh:

//note: từ phiên bản JAVA 7 có thể sử dụng kiểu String thay vì chỉ int.
switch(<biểu thức có kiểu int>)
{
case A: break;
case B: break;
...
default: break;
}


Lệnh Vòng lặp:


//lặp số thông thường
for(int i=0;i<10;i++){//lệnh; }

/*Duyệt các phần tử của mảng: 
duyệt các phần tử kiểu int trong mảng a. i là giá trị các phần tử).
*/
for(int i: a) System.out.println(i);


/*Duyệt các thành phần của đối tượng Iterable.
note: chỉ duyệt các phần tử của mảng or đối tượng kiểu Iterable, chứ không là 1 đối tượng của lớp khác.
*/


//Lặp khi kiểm tra điều kiện vẫn còn giá trị (boolean) true của biểu thức (lệnh).
//kiểm tra trước.
while(<condition>){ //lệnh; }

//kiểm tra sau.
do{
    ....
}while(<condition>);


//Lệnh chuyển hướng:   lệnh ngắt ra khỏi vòng lặp.
break;

//Lệnh chuyển hướng:  lệnh tiếp tục với phần tử tiếp theo.
continue;

/* Khi sử dụng chuyển hướng, có thể mang ý nghĩa chuyển hướng đến 1 nhãn đại diện cho 1 đối tượng. Nhãn được sử dụng hữu ích trong vòng lặp !
*/
//nhãn của vòng lặp.
label_1:
for(int i=0;i<10;i++)
for(int j=0;j<10;j++)
{
         if(i>5) break label_1;   //ngắt đến vòng lặp ngoài.
}

Làm việc với mảng

/*
Kiểu ngăn chứa hay mảng biểu thị [] sau tên kiểu. Mỗi 1 cặp [] là mảng 1 chiều, 2 cặp [][] là mảng 2 chiều....

+Coi mảng là 1 lớp phải được instance, để định trước số phần tử của mảng.
*/

//2 cách khai báo mảng.

cách 1: int[] bien;

cách 2: int bien[];

//khai báo & gán luôn giá trị.

int bien[]={1,2,3,...};

int[][] bien1={{1,2},{3,4}}

//Chỉ khai báo số phần tử của mảng.

int bien2[]=new int[10];

int[] bien2=new int[10];

//truy cập, thiết lập giá trị vào phần tử của mảng

bien[0];

bien1[0][0]; bien1[0][1];...

Vận chuyển dữ liệu

Hàm, cấu trúc, lớp, interface

Hàm
//tạo hàm có kiểu cần phải được trả về giá trị
Kieu Ten_ham(<tham_so_neu_co>){

             //lệnh trả giá trị về cho hàm.
     return value;

}

//hàm không kiểu, không được trả về giá trị.
void Ten_ham(<tham_so_neu_co>){}

//Khai báo biến tham số rõ ràng, mỗi tham số cách nhau dấu , :
ie: (int a, int b,..)
(int a,b)  //sao


/*Phương thức có tên trùng nhau (overloading methods):
Các phương thức có thể có tên trùng nhau nhưng kiểu or các tham số phải khác nhau.
ie:
*/
void get(){}
void get(String txt){}



/*Nếu không xác định có bao nhiêu tham số cho kiểu dữ liệu này được truyền vào, thì sử dụng: 
Kieu_3 dấu (.)_dấu cách_thamSo.
Lúc này thamSo là mảng các tham số & Chúng được truy cập theo kiểu mảng.
*/
void ham1(int... t){
t[0];t[1];..
}
void ham2(Object...t){}
void ham3(String t1, int... t2){}
...


/*Truyền biến đơn vào hàm là truyền tham trị:  
tức mọi thay đổi của biến diễn ra trong hàm đều không có tác dụng khi ra khỏi hàm => áp dụng cho các biến đơn thông thường (tức chỉ chứa 1 giá trị). 
*/
int a=10;
cong_them_2(a);

/*Truyền đối tượng/mảng vào hàm là truyền tham biến: 
tức truyền biến vào hàm, mọi thay đổi của biến diễn ra trong hàm đều có ảnh hưởng tới biến khi ra khỏi hàm => áp dụng cho các đối tượng có nhiều giá trị, thành phần. ie: mảng, đối tượng. 
*/
int[] bien={1,2,3};
void set(int[] tm){
     tm[0]=10;
}
System.out.println(bien[0]);



Interface
Interface chứa các hàm prototype chưa có nội dung để ràng buộc cho lớp phải có nó.
tạo interface.


//tạo interface.
interface rangbuoc1{
public ham1();
....
}

//thực thi 1 or nhiều interface sử dụng từ kháo implement. Các interface cách nhau bởi dấu ( , ) nếu có nhiều.
class lop1 implement racbuoc1, racbuoc2,...{}


Lớp


//Tạo lớp đơn giản:
class ten_lop{


}

//Danh nghĩa của lớp:
public, final, abstract.


Kế thừa lớp khác để sử dụng các thành phần của nó, sử dụng từ khóa : extends
note: 1 lớp chỉ được kế thừa tối đa 1 lớp khác. Để 1 lớp có nhiều kế thừa thì các lớp trực tiếp của nó cũng  phải được kế thừa.


//Kế thừa 1 or nhiều lớp.
class lop1 extends lop2{}


class a{}
class b extends a{}
class c extends b{} --> được kế thừa a & b.

//nếu có cả kế thừa & thực thi interface, thì kế thừa trước & thực thi interface sau.
class a extends b implements c,d..{}



Thành phần trong lớp có 2 tên gọi: Biến & phương thức (hàm).
Danh nghĩa của chúng:
Nhóm thuộc instance:
public: truy cập được cả trong lẫn ngoài, cho phép kế thừa.
private: chỉ truy cập được bên trong đối tượng, không cho phép kế thừa.
protected: chỉ truy cập được bên trong đối tượng, cho kế thừa.
Nhóm thuộc lớp:
static: không thuộc thành phần riêng của instance mà thuộc lớp (chung) . Thành phần này các instance của lớp đều được chia sẻ.


Note: 
- Mặc định danh nghĩa của thành phần là public.
- Có thể kết hợp danh nghĩa, không quan trọng thứ tự nhưng vẫn tuân theo 2 nhóm: thuộc instance & thuộc lớp.
final static/public/private/protected
public/private/protected static








//tạo lớp trực tiếp ở root thì không ở dạng static
class lop1{}


//tạo thành phần phải trực tiếp trong lớp, không được trong 1 phương thức.
class lop1{
     public int bien1;
     static float bien2;
     void hello(){
            public String txt="Hoang";   //sai !
            System.out.println("Hello world !");
     }
}

//Thành phần constructor:
Ten_Lop(<doi_so_neu_co>){....}


//Tạo 1 instance.
Lop1 bien = new Lop1(<tham_so_neu_co>);


//Sử dụng this để chỉ định thành phần của lớp, nếu tham số trùng tên.
class c2{
  public int i;
  c2(int i)
  {
      this.i=i;
  }
}


//this để chỉ instance trong lớp.
class lop1{
   public int i;
   lop1()
   {
      this(10);
   }
   lop1(int a)
   {
      i=a;
   }
}

//Truy cập vào thành phần static (thông qua tên lớp or qua 1 instance =>bên ngoài lớp) or (trực tiếp bên trong lớp instance).
Lop1.static_member;
or:
new Lop1().static_member;


//Truy cập vào thành phần không static: chỉ từ 1 thành phần không static or truy cập vào nó từ bên ngoài.


class c1{
  static int t;
  void get(){return "Hoang";}
  public c1(){
      t=10;
      get();
  }
}


/*Truy cập vào thành phần static & không static (public/ no identifer) từ bên ngoài lớp: Sử dụng dấu '.' để truy cập vào các thành phần thông qua instance.
*/
doituong.ham1();  //gọi hàm
doituong.item1;  //lấy giá trị của biến.

//tạo thành phần biến không cho phép sửa đổi (hằng) bởi final, phải được khởi tạo giá trị & ko cho phép sửa đổi.
final int PI=3.14;

//hàm static chạy ngay khi khởi tạo instance. => mục đích khởi tạo biến static.
static{
       //lenh;
}

//hàm không static chạy ngay khi khởi tạo instance. => mục đích khởi tạo thành phần static & ko static.
{
        //lenh;
}


Tạo lớp bên trong lớp (lớp con) chỉ thuộc về lớp đó, quyền: truy cập được các thành phần của lớp & instance.
danh nghĩa lớp cũng có 2 dạng: static or không static.
-Lớp static chỉ truy cập được các thành phần static của lớp mẹ.

-Lớp không static thì truy cập được các thành phần của lớp mẹ.


//tạo lớp trực tiếp ở trong lớp

class lop1{
     static class lop1_1{}
     class lop2{}
}


//truy cập lớp con static từ thành phần lớp mẹ như thành phần static của lớp: thông qua tên lớp mẹ or trực tiếp.
LopMe.LopCon bien=new LopMe.LopCon(...);
or:
LopCon bien=new LopCon(...);

//truy cập lớp con không static trực tiếp từ thành phần của lớp mẹ.
LopCon bien=new LopCon(...);

Enum:
-Là 1 kiểu dữ liệu được sử dụng như lớp nhưng đặc biệt có chứa các giá trị hằng, với tên hằng là giá trị của chúng.
-Khi khởi tạo biến kiểu enum, sẽ gọi lớp enum n lần (n: là số lượng các hằng có trong enum).


//tạo enum trực tiếp trong lớp, chứa những hằng (kết thức bởi ;) & có thể chứa các biến - phương thức
enum day{
    thu2, thu3, thu4;  //gọi lớp enum 3 lần, bằng số lượng hằng.
    void get(){}
}



//truy cập enum từ mọi thành phần của lớp mẹ/ lớp con thông qua tên enum.
enum day{thu2, thu3}
void get{
     System.out.print(day.thu2);


}

//biến kiểu enum có giá trị là 1 trong các giá trị của enum.
enum day{thu2, thu3, thu4}
void get(day t1){
      if(t1==day.thu2) System.out.print(t1.thu2);
      switch(t1)
      {
           case thu3: System.out.print("Thu 3");
      }
}

//chỉ gán giá trị vào biến enum, chứ không gán cả enum. Từ biến có thể truy cập được các trị khác của nó.
enum day{thu2, thu3}
day t1=day.thu2;
day t2=day;    //Sai.
t1.thu3;

Read More

__{api}__Sử dụng các đối tượng trong Java

Nếu không biết trước kiểu của đối tượng thì sử dụng kiểu chung.

Kiểu cho mọi kiểu.

Object
ie: Object t="Hoang";

Lớp cho mọi lớp.
Class


//lấy kiểu lớp & tên kiểu lớp của đối tượng.
obj.getClass().getName();
ie:
Class c="shdfjksdf".getClass();
c.getName();


//Kiểm tra bien là 1 đối tượng của Lop1.
bien instanceof Lop1

Regex trong java.

Làm việc với mảng

copy mảng.
//copy từ vị trí 2 của copyFrom với 7 phần tử vào copyTo bắt đầu từ vị trí 0.
System.arraycopy(copyFrom, 2, copyTo, 0, 7);

//tham số kiểu mảng
int[] tham_so

//không sử dụng giá trị mảng trực tiếp, phải được sử dụng qua biến.
int[] mang={1,2,3}
System.out.println({1,2,3});   //Sai !

//đếm số phần tử của mảng
mang.length

//

Lớp chuỗi

Lớp: String


cộng chuỗi.

"Quach "+"Hoang";


//truyền ngăn chứa (Mảng) a các ký tự/chuỗi để gộp thành 1.
new String(a);

Chuyển thành chữ hoa.
txt.toUpperCase();

chuyển thành chữ thường.
txt.toLowerCase();

tách chuỗi.

Ký tự đặc biệt.

\n: xuống dòng.
\t: 1 khoảng tab.

Làm việc với số

Các hàm toán học
//căn bậc 2
Math.sqrt(4);

//

Hàm phổ biến hệ thống

Thoát khỏi ứng dụng.
System.exit(1);

Hiển thị thông tin.

//không xuống dòng
System.out.print(..);

//có xuống dòng.
System.out.println(..);

//xuất nhiều kiểu dữ liệu
System.out.printtf("chuỗi hiển thị",bien1, bien2,...);
-Các định dạng sau sẽ được gắn với mỗi biến & đặt vị trí trong chuỗi để hiện thị.
%d: hiển thị số nguyên.
%f: số thực.
%s: chuỗi.



Hiển thị lỗi

//hiển thị chuỗi thông báo lỗi có mầu đỏ.
System.err.print("Loi !");  or println

Lớp, hàm, cấu trúc

Hàm.







Lớp

Regex

Read More

__{ideal}__Học wordpress

df

Read More

Mẹo sử dụng nukeviet

//Bật lỗi nukeviet để coding hiệu quả hơn.
error_reporting(2047);

Read More

Sử lý lấy keywords cho 1 bài viết của module

Mẹo:

-Lấy trường keywords từ record bài viết.

-Nếu không có thì lọc keywords từ nội dung bài viết.

-Nếu không thì lọc từ tiêu đề title.

=> Sau đó update lại vào cột keywords của bài viết đó, để lần sau không phải tạo nữa.


if(!empty($row['keywords']))
{
    $key_words=$cache['key_words']=$row['keywords'];
}else
{
    $key_words=nv_get_keywords($row['bodytext']);

    if(empty($key_words))
    {
$key_words=nv_unhtmlspecialchars($row['title']);
        $key_words=strip_punctuation($key_words);
$key_words=trim($key_words);
$key_words=nv_strtolower($key_words);
$key_words=preg_replace("/[ ]+/",",",$key_words);
    }


    $cache['key_words']=$key_words;

    $query="UPDATE`".NV_PREFIXLANG."_".$module_data."` SET `keywords`=".$db->dbescape($key_words)." WHERE `id` =".$id;

    $db->sql_query($query);
}

Read More

Thứ tự các bài viết

Thứ tự các bài viết:

Có 1 trường ghi thứ tự bài viết weight.

-Các bài viết hiển thị theo nguyên tắc tăng dần của vị trí weight:
Show các records của bảng.
-Thêm bài viết:
đếm số records + 1 & ghi vào weight cho bài viết mới.
-Xóa 1 bài viết bất kỳ:
Xóa bài viết & sửa lại các records sau record bị xóa từ vị trí vị trí của record bị xóa đến n.
-sửa vị trí hiển thị bài viết:
Record sửa trùng với vị trí record nào thì đổi vị trí cho nhau.

Read More

Kinh nghiệm regex

Lời nói đầu:
regular expression (hay còn gọi tắt là regex) là 1 công cụ rất mạnh về việc sử lý chuỗi.
Công cụ:
-Phiên bản trực tuyến: http://gskinner.com/RegExr/
-Download về máy tính: http://www.gskinner.com/RegExr/desktop/

*Một số lưu ý khi dùng regex trong các ngôn ngữ:
javascript: /regex/g,i,m
php: /regex/

*Nguyên tắc:
regex là 1 mẫu, sau khi nhập mẫu nó sẽ tìm mẫu đó cho bạn. Khi tìm được mẫu đầu tiên, nó sẽ tiếp tục tìm mẫu khác nếu thuộc tính global được bật lên.
So sánh 2 ví dụ sau:
Bài toán: tìm 1 ký tự chữ cái thuộc [a-z] tiếp đó là 1 ký tự trống or không có.

//tìm chuỗi xuất hiện đầu tiên.

//có or không ký tự A.
(A)?

//đến ký tự này rồi dừng lại tách ra & tiếp tục tìm mẫu mới. Note: tính cả ký tự đó.
?(x)

//đến ký tự đó.

//sử dụng hàm split, tách các chuỗi bởi 1 or nhiều ký tự nào đó.
ie: tách chuỗi bởi ký tự a, b: [^ab]

//chú ý hiệu ứng xuyên suốt, tìm bất kỳ ký tự nào.
.+
note: khi sử dụng hiệu ứng này nên cẩn thận vì nó sẽ gộp kết quả của bạn thành 1 chuỗi.
ví dụ: Bài toán trên nếu thêm hiệu ứng xuyên suốt ở đầu: lúc này nó đã tìm mọi ký tự, công việc tìm kiếm của bạn sau đó cũng vô nghĩa.

//tìm chuỗi ký tự nhưng chừa nó ra

(?<=*)ky_tu_sau_do...

ie: (?<=<u>)[\d]+(?<=<\/u>) với chuỗi: "<u>3467835435</u>"

Read More

Tạo module đơn giản chứa các bài viết.

Bài tập:

Tạo 1 module đơn giản có tên test có chứa dữ liệu là các bài viết. Khi vào chạy vào module thì:

-hiển thị bài đầu tiên & các link của bài khác ở phái dưới.

hoặc:

-hiển thị các bài dưới dạng giới thiệu, click vào link bài nào thì hiển thị nội dung chi tiết cho link bài đó & phía dưới có chứa link của các bài khác.

---------------------------------------------------

Chuẩn bị các thư mục cho module:

*test/

• version.php
• action.php
• funcs/
• functions.php
• admin/
• admin.functions.php
• language/
• theme.php

version.php

if ( ! defined( 'NV_ADMIN' ) or ! defined( 'NV_MAINFILE' ) ) die( 'Stop!!!' );

$module_version = array(

    "name" => "module thử nghiệm", //

    "modfuncs" => "main", //chức năng mặc định.

    "is_sysmod" => 0, //

    "virtual" => 1, //

    "version" => "3.0.01", //

    "date" => "Wed, 20 Oct 2010 00:00:00 GMT", //

    "author" => "@hoang", //

    "note" => "", //

    "uploads_dir" => array( 

        $module_name 

    )

);

action.php

//tạo bảng với tiền tố, tên là tên module.

$sql_drop_module = array();

$sql_drop_module[] = "DROP TABLE IF EXISTS `" . $db_config['prefix'] . "_" . $lang . "_" . $module_data . "`;";

$sql_create_module = $sql_drop_module;

$sql_create_module[] = "CREATE TABLE `" . $db_config['prefix'] . "_" . $lang . "_" . $module_data . "` (

  `id` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,

  `title` varchar(255) NOT NULL,

  `alias` varchar(255) NOT NULL,

  `bodytext` mediumtext NOT NULL,

  `keywords` mediumtext NOT NULL,

  `weight` smallint(4) NOT NULL DEFAULT '0',

  `admin_id` mediumint(8) unsigned NOT NULL DEFAULT '0',

  `add_time` int(11) NOT NULL DEFAULT '0',

  `edit_time` int(11) NOT NULL DEFAULT '0',

  `status` tinyint(1) unsigned NOT NULL DEFAULT '0',

  PRIMARY KEY (`id`),

  UNIQUE KEY `alias` (`alias`)

) ENGINE=MyISAM";

//
//liệt kê các bài viết theo thứ tự. Chức năng sửa, xóa, thay đổi vị trí.

Read More